Ethers.js Uniswap UniswapV3 – How to Decode Uniswap Universal Router Transaction in Ethers.js

ethers.jsuniswapuniswapv3

Uniswap has recently rolled out a new Universal router (blog here: https://docs.uniswap.org/contracts/universal-router/technical-reference)

I've decoded a transaction using the Uniswap ABI and ethersjs parseTransaction into something like so:

TransactionDescription {
  args: [
    '0x0b00',
    [
      '0x0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000009184e72a000',
      '0x0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000009184e72a00000000000000000000000000000000000000000000000000000000000000038e000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc20001f4dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000'
    ],
    BigNumber { _hex: '0x63c87f23', _isBigNumber: true },
    commands: '0x0b00',
    inputs: [
      '0x0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000009184e72a000',
      '0x0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000009184e72a00000000000000000000000000000000000000000000000000000000000000038e000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc20001f4dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000'
    ],
    deadline: BigNumber { _hex: '0x63c87f23', _isBigNumber: true }
  ],
  functionFragment: {
    type: 'function',
    name: 'execute',
    constant: false,
    inputs: [ [ParamType], [ParamType], [ParamType] ],
    outputs: [],
    payable: true,
    stateMutability: 'payable',
    gas: null,
    _isFragment: true,
    constructor: [Function: FunctionFragment] {
      from: [Function (anonymous)],
      fromObject: [Function (anonymous)],
      fromString: [Function (anonymous)],
      isFunctionFragment: [Function (anonymous)]
    },
    format: [Function (anonymous)]
  },
  name: 'execute',
  signature: 'execute(bytes,bytes[],uint256)',
  sighash: '0x3593564c',
  value: BigNumber {
    _hex: '0x3593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000063c87f2300000000000000000000000000000000000000000000000000000000000000020b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000009184e72a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000009184e72a00000000000000000000000000000000000000000000000000000000000000038e000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc20001f4dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000',
    _isBigNumber: true
  }
}

However, I can not understand how I could decode the inputs into the correct values.

The technical reference suggests that the bytes array for input should have the following things in it:

The second parameter for the function is an array of bytes strings. Each element in the array is the abi-encoded input that will be used for the respective command.


V3_SWAP_EXACT_IN
address The recipient of the output of the trade
uint256 The amount of input tokens for the trade
uint256 The minimum amount of output tokens the user wants
bytes The UniswapV3 encoded path to trade along
bool A flag for whether the input tokens should come from the msg.sender (through Permit2) or whether the funds are already in the UniversalRouter

However, the bytes array only has length 2:

        inputs: [
      '0x0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000009184e72a000',
      '0x0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000009184e72a00000000000000000000000000000000000000000000000000000000000000038e000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc20001f4dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000'
    ],

What am I misunderstanding here, and how can I decode a universal router transaction

Best Answer

The misunderstanding seems to come from the inputs.

You can see that in the object you mentioned there are these lines:

    commands: '0x0b00',
inputs: [
  '0x0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000009184e72a000',
  '0x0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000009184e72a00000000000000000000000000000000000000000000000000000000000000038e000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc20001f4dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000'
],

Where the commands (Commands.sol) is interpreted as:

0x: Hex symbol
0b: WRAP_ETH (1st function)
00: V3_SWAP_EXACT_IN (2nd function)

That is why you see 2 elements in the inputs array. The first element is the inputs corresponding to the first function (WRAP_ETH) The second element in the array are the inputs corresponding to V3_SWAP_EXACT_IN

Let's look at the first function for example and decode that.

  //inputs[0] split every 64 characters
  0000000000000000000000000000000000000000000000000000000000000002 //addres of recipient
  000000000000000000000000000000000000000000000000000009184e72a000 //amount of ETH

Address of recipient: HEX for 2 (2 meaning the contract is the recipient Constants.sol)
Amount of ETH in WEI where 0x9184e72a000 equals 10000000000000 in decimal (10000000000000 wei = 0.00001 Ether)

Using this same method you can do the same thing for V3_SWAP_EXACT_IN.

Note there might be tools to decode these by default if you have the ABI, but this is why you see 2 inputs only.

Related Solutions

JavaScript – Decode Uniswap Universal Router’s Execute Function Parameters with Ethers.js

You are correct that the V3_SWAP_EXACT_IN itself takes in 5 parameters.

But the 4th parameter(path) is a bytes array, and they also include fees and a number of offsets to properly build the path. You can check out more in their V3Path.sol smart contract and V3SwapRouter.sol.

Judging by the code snippet you included you managed to decode the universal function with ethers interface. I recommend you do the same with the V3 function too like so:

const abiCoder = new AbiCoder();
decoded = abiCoder.decode(["address", "uint256", "uint256", "bytes", "bool"], inputForFunction);

Using this you can get the corresponding parameter to each input for the V3_SWAP_EXACT_IN function. Basically you create a mini interface with just the function you need to decode. As long as you know the inputs it should give the correct results.

Running the code snippet should result in something like this:

[
  '0x0000000000000000000000000000000000000001',
  BigNumber { _hex: '0x06ccf946da6cf708', _isBigNumber: true },
  BigNumber { _hex: '0x04c72ae4b04a0a42db7f', _isBigNumber: true },
  '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc200271000c83aecc790e8a4453e5dd3b0b4b3680501a7a7',
  false
]

Now there are actually 5 inputs here (recipient,input,minOut,path,fromowner)

Next challenge would be decoding the path itself, since it is still in the incorrect format. If you check out the V3Path.sol you can see different offsets for address, fees you have to account for those when extracting the addresses from the path.

I use the following function for my application:

function extractPathFromV3(fullPath, reverse = false) {
    const fullPathWithoutHexSymbol = fullPath.substring(2);
    let path = [];
    let currentAddress = "";
    for (let i = 0; i < fullPathWithoutHexSymbol.length; i++) {
        currentAddress += fullPathWithoutHexSymbol[i];
        if (currentAddress.length === 40) {
            path.push('0x' + currentAddress);
            i = i + 6;
            currentAddress = "";
        }
    }
    if (reverse) {
        return path.reverse();
    }
    return path;
}

It takes each address from the path, excludes the fee(skipping 6 bytes) and can reverse the path since V3_SWAP_EXACT_OUT path is reversed by default so that might be needed too.

You can check out my full implementation here if you are interested uniswap-universal-decoder

Hope it clarifies it a bit more.

Best Answer

Related Solutions

JavaScript – Decode Uniswap Universal Router’s Execute Function Parameters with Ethers.js

Related Topic