How to encode structs with a user defined type?

[alexisgauba]

Hey ya'll! Had a question about encoding structs with user defined types using ethers.js.

With web3.js you can use web3.eth.abi.encodeParamters and pass in a JSON interface of a struct w/ a custom type, and I'm trying to figure out how to do the same with ethers.

When I try the same syntax as I use with web3.js it gives me Object literal may only specify known properties, and ''Order[]'' does not exist in type 'ParamType’

When I try to do this by turning a JsonFragmentType into a ParamType it gives me Object literal may only specify known properties, and ''Order[]'' does not exist in type 'JsonFragmentType[]

I see that the .from input needs to be a JsonFragmentType and will call fromObject. It looks like JsonFragmentType takes in an array of components of JsonFragmentType, so not sure how to encode the custom type here.

For reference here is the code using web3.js:

web3.eth.abi.encodeParameters(
      [
        'address',
        {
          'Order[]': {
            makerAddress: 'address',
            takerAddress: 'address',
            feeRecipientAddress: 'address',
            senderAddress: 'address',

            makerAssetAmount: 'uint256',
            takerAssetAmount: 'uint256',
            makerFee: 'uint256',
            takerFee: 'uint256',
            expirationTimeSeconds: 'uint256',
            salt: 'uint256',

            makerAssetData: 'bytes',
            takerAssetData: 'bytes',
            makerFeeAssetData: 'bytes',
            takerFeeAssetData: 'bytes',
          },
        },
        'uint256[]',
        'bytes[]',
      ],
      [account, orders, amounts.map(amt => amt.toString()), orders.map(order => order.signature)],
    )
  })

And what I'm trying with ethers where I'm running into the above issues with encoding the Order[] type.

ethers.utils.defaultAbiCoder.encode(
        [ 'address',
          ethers.utils.ParamType.from(
            {
              components: {
                'Order[]': {
                  makerAddress: 'address',
                  takerAddress: 'address',
                  feeRecipientAddress: 'address',
                  senderAddress: 'address',

                  makerAssetAmount: 'uint256',
                  takerAssetAmount: 'uint256',
                  makerFee: 'uint256',
                  takerFee: 'uint256',
                  expirationTimeSeconds: 'uint256',
                  salt: 'uint256',

                  makerAssetData: 'bytes',
                  takerAssetData: 'bytes',
                  makerFeeAssetData: 'bytes',
                  takerFeeAssetData: 'bytes',
                },
              }
            },
          ),
          'uint256[]',
          'bytes[]',
        ], 
        [account, orders, amounts.map(amt => amt.toString()), orders.map(order => order.signature)],
    )

[ricmoo]

The ABI coder takes in the same format that the Solidity copier spits out in the ABI, so you can just copy it from there.

Here is what your examples would need:

ethers.utils.defaultAbiCoder.encode(
        [ 'address',
          {
            type: "tuple[]",
            name: "orders",
            components: [
              { name: "makerAddress", type: 'address' },
              { name: "takerAddress", type: 'address' },
              { name: "feeRecipientAddress", type:'address' },
              { name: "senderAddress", type:'address' },

              { name: "makerAssetAmount", type:'uint256' },
              { name: "takerAssetAmount", type:'uint256' },
              { name: "makerFee", type:'uint256' },
              { name: "takerFee", type:'uint256' },
              { name: "expirationTimeSeconds", type:'uint256' },
              { name: "salt", type:'uint256' },

              { name: "makerAssetData", type: 'bytes' },
              { name: "takerAssetData", type:'bytes' },
              { name: "makerFeeAssetData", type:'bytes' },
              { name: "takerFeeAssetData", type:'bytes' },
            ]
          },
          'uint256[]',
          'bytes[]',
        ],
        [ account, orders, amounts, signatures ],
    )

Keep in mind the Web3.js library just uses the ethers ABI coder under-the-hood, so I'm not sure where they got that format from, but they are coverting it to the ethers format (i.e. the Solidity format) somewhere in there before calling the ethers encode method. Do you have any info on that representation? If it is a common structure, I can look into adding a parser for it.

For your signatures, you might also be interested in checking out EIP-2098, which uses two bytes32 instead of a bytes; two bytes32 requires 64 bytes to encode, whereas a bytes for signatures requires 160 bytes, including the various pointers and lengths.

Let me know if you still have any issues. :)

[Whytecrowe]

Is there a way now on v6 to pull a struct type from a contract object? Trying to figure out how to encode a struct from a contract in TS with the help of ethers v6.

[ricmoo]

You can always use the struct type, which is just the types wrapped in parenthesis. You can also use the JSON description of a struct; either way ethers supports anything Solidity can do. :)

[Whytecrowe]

I am currently doing it as such:

.encode(
  ["tuple(uint,uint)"],
  [[5n, 5n]]
)

Was wondering if there's a more elegant way, where I can pull data/types from contract objects or something like that (less manual), so that it adapts to changes on the contract itself, but can't seem to find a better way.

[ricmoo]

I don’t think struct types are currently exported in the ABI? I requested it years ago, but the Solidty team didn’t want meta-data present in the ABI. Has this changed?

[Whytecrowe]

I don't think so. Looked around today, but couldn't find. That's what brought me to this question, thinking maybe I am not aware of better ways to do struct encoding.