Convert arrayified bytes data to string

[clemsos]

Ethers Version

5.7.2

Search Terms

bytes to string, encodeFunctionData, interface, arrayify

Describe the Problem

Hello, I have a contract where I need to pass an encoded call data to a contract as a string (instead of bytes) - no other choice :/

I am using encodeFunctionData to encode the function call, then using arrayify to parse the string as bytes, then Buffer.from(bytes).toString() to parse the bytes as string and pass it to the solidity contract where I can just do an address.call(bytes(myStringBytes)).

However when I receive the string on the contract, there is a difference in the bytes which cause the .call to fail. I supposed it is related to the way Buffer.from convert the uint8 array to string. I have tried multiple encoding and other methods with no luck so far.

Any idea what will be the proper way to convert an (arrayified) array of bytes to string so it can be passed as a string argument to a solidity function?

Many thanks !

Code Snippet

const TestEncode = await ethers.getContractFactory('TestEncode')
const testEncode = await TestEncode.deploy()

const sig = "purchase(uint256[1],address[1],address[1],address[1],bytes[1])"

const args = [
    [0], 
    [ZERO], 
    [ZERO],
    [ZERO],
    [[]], // empty bytes
]

// encode func call
const calldata = await testEncode.interface.encodeFunctionData(sig, args)

// convert to bytes
const bytes = ethers.utils.arrayify(calldata)

// convert bytes to string
const strBytes = Buffer.from(bytes).toString()
      
await testEncode.log(strBytes)

Contract ABI

/** 
* The TestEncode.sol contract used to reproduce
**/


// SPDX-License-Identifier: MIT

pragma solidity >=0.8.6 <0.9.0;
pragma abicoder v2;

import "hardhat/console.sol";

contract TestEncode {

  function log(string memory _data) external {
    // encode directly in the contract to get a working version of the bytes call data
    bytes memory encoded = abi.encodeWithSignature(
      "purchase(uint256[1],address[1],address[1],address[1],bytes[1])", 
      [uint(0)],[address(0)],[address(0)], [address(0)],[bytes('')]
    );
    console.log('expected:');
    console.logBytes(encoded);

    // make sure the encoded call actually works
    (bool success,) = address(this).call(encoded);
    if(!success) {
      revert('purchase call failed');
    }
    
    // show the encoded passed from arg
    console.log('actual:');
    console.logBytes(bytes(_data));
    
    // this call reverts
    (bool successActual,) = address(this).call(bytes(_data));
    if(!successActual) {
      revert('purchase call failed');
    }
  }

 function purchase(
    uint256[1] memory _values,
    address[1] memory _recipients,
    address[1] memory _referrers,
    address[1] memory _keyManagers,
    bytes[1] memory _data
  ) external payable returns (uint) {
    console.log("CALL SUCCESS");
  }
}

Errors

Not an error but the log where you can see the difference in both (additional efbfbd bytes)

expected:
0x5a702aea000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000
CALL SUCCESS

actual:
0x5a702aefbfbd000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000efbfbd00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000

Error: VM Exception while processing transaction: reverted with reason string 'purchase call failed'

Environment

Hardhat

Environment (Other)

No response

[ricmoo]

It's worse than just an additional efbfbd. The 8th nibble is actually wrong; it's an f instead of an a.

I think there is another problem with the code though. I don't believe the solc bytes operation will do the hex decoding for you, so what you actually need to compute is a string representation, which means a string full of invalid bytes, which ethers will likely complain about. You can try returning the length of bytes(_data) to check that it is what you expect though. And you would probably have to change a lot of the Solidity to make that work, unless the thing you are calling is expecting hex-encoded data?

Everything seems weird about those weird bytes though. It seems like maybe the selector is wrong? Or that something is being truncated somewhere?

My first thoughts though, are this isn't a bug in ethers, so I'll move it to discussions for now.