String – How to Split a String in Solidity

slicestring

I'm using the OpenZeppelin Preset of the 1155 Token Standard. (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC1155/presets)
I'm able to mint tokens with that and I'm able to transfer 4 arguments with the transaction:

address (of the receiver)
id (of the Token)
amount (amount of Tokens)
data (additional data in bytes format)

I use the id and data for transmitting data
Now I'm confronted with the issue, that I want to transfer two variables (in string format) in the data field.
First of all I have to convert the field data from bytes into string.
Then I want to split the content of the data field into two variables.
The one variable got 13 characters, the other one 15.
Then I pobably have to assign each split to these two variables.
With emit Event I transfer both variables on the blockchain and can access it in the Logs.

Please pardon, I'm a bloody noob in coding with solidity.
Does someone knows how i can formulate a function that converts bytes to string, split the string into two parts and then assign it to new variables?

Best Answer

If it is yourself who is packing those two strings s1 and s2 into one bytes, then you may:

At the source (in JavaScript):

const data = abiCoder.encode(["string", "string"], [s1, s2])
Pass data via the contract function
At the receiving end (in Solidity):

(string memory s1, string memory s2) = abi.decode(data, (string, string))

Doing it this way avoids string operations altogether.

P.S. Keep in mind that data is not intended for consumption by the transfer function itself, but it is intended for consumption by the receipient of the transfer (if that recipient is a compliant ERC1155TokenReceiver contract.)

Related Solutions

Keccak256 – How to Pass a String to be Hashed Using Keccak256

try this snipet

function bytes32ToString(bytes32 x) constant returns (string) {
    bytes memory bytesString = new bytes(32);
    uint charCount = 0;
    for (uint j = 0; j < 32; j++) {
        byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
        if (char != 0) {
            bytesString[charCount] = char;
            charCount++;
        }
    }
    bytes memory bytesStringTrimmed = new bytes(charCount);
    for (j = 0; j < charCount; j++) {
        bytesStringTrimmed[j] = bytesString[j];
    }
    return string(bytesStringTrimmed);
}

 function someFunction(bytes32 _string) returns(bool){
    bool result = false;
    bytes32 hashparameter = sha3(bytes32ToString(_string));
    bytes32 hashstring = sha3("hello");
    if(hashstring == hashparameter) {
        result = true;
    }

    return result;

}

the first function converts bytes32 to string then passes the result to hashing function. I've tried it gives true for "hello".

Solidity Utf-8 Decoding – The Unicorn Mystery on Decoding Valid UTF-8 Encoded Bytes

Unlike some of the comments suggest, the unicorn symbol 🦄 (U+1F984) is located in the contract's symbol name. You can check this by running the following in a web3 browser's console:

// taken from https://github.com/flyswatter/human-standard-token-abi/blob/master/index.js
var tokenAbi = [
  {
    "constant": true,
    "inputs": [],
    "name": "name",
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_spender",
        "type": "address"
      },
      {
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "approve",
    "outputs": [
      {
        "name": "success",
        "type": "bool"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [],
    "name": "totalSupply",
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_from",
        "type": "address"
      },
      {
        "name": "_to",
        "type": "address"
      },
      {
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "transferFrom",
    "outputs": [
      {
        "name": "success",
        "type": "bool"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [],
    "name": "decimals",
    "outputs": [
      {
        "name": "",
        "type": "uint8"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [],
    "name": "version",
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "_owner",
        "type": "address"
      }
    ],
    "name": "balanceOf",
    "outputs": [
      {
        "name": "balance",
        "type": "uint256"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [],
    "name": "symbol",
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_to",
        "type": "address"
      },
      {
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "transfer",
    "outputs": [
      {
        "name": "success",
        "type": "bool"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": false,
    "inputs": [
      {
        "name": "_spender",
        "type": "address"
      },
      {
        "name": "_value",
        "type": "uint256"
      },
      {
        "name": "_extraData",
        "type": "bytes"
      }
    ],
    "name": "approveAndCall",
    "outputs": [
      {
        "name": "success",
        "type": "bool"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "constant": true,
    "inputs": [
      {
        "name": "_owner",
        "type": "address"
      },
      {
        "name": "_spender",
        "type": "address"
      }
    ],
    "name": "allowance",
    "outputs": [
      {
        "name": "remaining",
        "type": "uint256"
      }
    ],
    "payable": false,
    "type": "function"
  },
  {
    "inputs": [
      {
        "name": "_initialAmount",
        "type": "uint256"
      },
      {
        "name": "_tokenName",
        "type": "string"
      },
      {
        "name": "_decimalUnits",
        "type": "uint8"
      },
      {
        "name": "_tokenSymbol",
        "type": "string"
      }
    ],
    "type": "constructor"
  },
  {
    "payable": false,
    "type": "fallback"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "_from",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "_to",
        "type": "address"
      },
      {
        "indexed": false,
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "_owner",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "_spender",
        "type": "address"
      },
      {
        "indexed": false,
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "Approval",
    "type": "event"
  },
];

// get symbol
var tokenContract = web3.eth.contract(tokenAbi);
var instance = tokenContract.at("0x89205a3a3b2a69de6dbf7f01ed13b2108b2c43e7");
instance.symbol.call((thing1, thing2) => global.symbol = thing2);

Let's investigate this string:

symbol.length // Output: 2
symbol.codePointAt(0) // Output: 129412 (0x1F984)
symbol.split("").map(char => char.charCodeAt(0)); // Output: [55358, 56708]

Let's talk about UTF-8, the character encoding mist uses. According to FileFormat.info:

UTF-8 is a compromise character encoding that can be as compact as ASCII (if the file is just plain English text) but can also contain any unicode characters (with some increase in file size).

UTF stands for Unicode Transformation Format. The '8' means it uses 8-bit blocks to represent a character. The number of blocks needed to represent a character varies from 1 to 4.

What we have here is unicode code point: 29412 (0x1F984). It looks like solidity only supports encoding codepoints between 0x0000 (0) and FFFF (65535) using the \uNNNN syntax. Typically languages allow encoding with over this amount using surrogate characters. Solidity doesn't seem to.

No worries, we should be able to just put the hex encoding of the correct unicode sequence and the correct text should be rendered.

Contract:

pragma solidity ^0.4.11;

contract EmojiCon {
    string public constant working = hex"F09FA684";
    string public constant broken = "\uD83D\uDC36";
}

Test (truffle):

var EmojiCon = artifacts.require("./EmojiCon.sol");

contract('EmojiCon', function(accounts) {
  it("should match the string", async function() {
    const instance = await EmojiCon.deployed();
    const workingString = await instance.working.call();
    console.log(workingString);
  });

  it("shouldn't match the string", async function() {
    const instance = await EmojiCon.deployed();
    const brokenString = await instance.broken.call();
    console.log(brokenString);
  });
});

Unfortunately it won't compile:

Compiling ./contracts/EmojiCon.sol...
Compiling ./contracts/Migrations.sol...

/home/vm/ethereum/unicode/contracts/EmojiCon.sol:4:35: : Type literal_string (contains invalid UTF-8 sequence at position 3) is not implicitly convertible to
expected type string memory.
        string public constant working = hex"F09FA68421";
                                         ^-------------^
Compiliation failed. See above.

The error comes from here. It seems the validator chooses an incorrect value for count and stops too early. (isolation (original)). This seems to be a bug/missing feature in solidity. Hope this helps.

Best Answer

Related Solutions

Keccak256 – How to Pass a String to be Hashed Using Keccak256

Solidity Utf-8 Decoding – The Unicorn Mystery on Decoding Valid UTF-8 Encoded Bytes

Related Topic