How to decode input data from a transaction?

Question

I'm sending a transaction to an account with some data with the following command:

eth.sendTransaction({from:eth.accounts[0],to:eth.accounts[1],value:web3.toWei(1,"ether"),data:web3.toHex("http://localhost:8545")})

I'm getting this result, by extracting the log of the transaction (running with testRPC):

   tx hash         : 0xf654aee5ed23f9aeebd2d73c69c7b9c21a4862787966d09bcb09ed44efc1f252
   nonce           : 0
   blockHash       : 0x6ff8a0e3ac606abd2ede4331b82af52a0daa98448025051fb3b3d50f749aa49f
   blockNumber     : 1
   transactionIndex: 0
   from            : 0xf64918835bc21dff9e8210a807b3964d1be35dd0
   to              : 0x08f986b7535c2b72687d3cb193135f1c6e27c336
   value           : 1000000000000000000
   time            : 1483614904 Thu, 05 Jan 2017 11:15:04 GMT
   gasPrice        : 1
   gas             : 90000
   input           : 0x687474703a2f2f6c6f63616c686f73743a38353435

I want to decode the last line "input" and try to get "http://localhost:8545". I saw some work similar to my question here and here, but this is not working in my case. Moreover, i tried .toString('hex')) but it remains as hex.

How can I achieve this?

Thanks in advance

Answer 1

You can do web3.toAscii(transactionID.input) to return the data in readable format.

Read web3.toAscii

Answer 2

If you've heard about the ethers js library, it provides a fantastic function named parseTransaction, I found it after a very long search as it wasn't mentioned in any online forums and I'm still learning a lot about this stuff.

But I found it to be the best for decoding any sort of contract and associated function call.

    const ethers = require('ethers');
    const ABI = require('./abi.json'); // Contract ABI
    const provider = ethers.getDefaultProvider();

    const inter = new ethers.utils.Interface(ABI);

    (async() => {
      const tx = await provider.getTransaction('0xa30e9e19967bd3307feeddcf99b26be0d804cdc0ade6929f3b9328a95e388b4c');
        const decodedInput = inter.parseTransaction({ data: tx.data, value: tx.value});
    
        // Decoded Transaction
        console.log({
            function_name: decodedInput.name,
            from: tx.from,
            to: decodedInput.args[0],
            erc20Value: Number(decodedInput.args[1])
          });        
    })();

Answer 3

In order to decode data you can use a library called abi-decoder

You will need to provide an ABI for the smart contract you want to decode, then just paste the input data. Very simple.

The only downfall would happen if your input data happens to be smart-contract creation "Constructor" then, in that case, you will have to change the library to accommodate with that.

Answer 4

UI Tools

• cleanunicorn.github.io/santoku
• etid.wtd.ru
• ethtx.info
• moesif.com/solidity-abi-hex-decoder/decode

Note for these you will need the ABI of the contract.

Node Packages

• @ethersproject/abi (part of the umbrella package ethers)
• abi-decoder
• ethereum-input-data-decoder

Recommendation

Use @ethersproject/abi, it's the safest approach of all. Ethers is battle-tested in thousands of Ethereum projects and there's likely no bug in its implementation of ABI encoding/ decoding.

Answer 5

We've made a nice tool for decoding. Just paste the transaction hash into input and get the result. Check it It works with Mainnet, Kovan, Ropsten and Rinkeby, but contract code must be verified in Etherscan. We use Etherscan API to get transaction and contract data, and web3 for decoding.

Answer 6

This JavaScript/Node.js library can decode smart contract input data and contract creation input data given the JSON abi:

https://github.com/miguelmota/ethereum-input-data-decoder

Answer 7

A full definition of what you're trying to decode (the input data field) is here: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI. It's tough-going, but I was able to write some C++ that fully parses function arguments as recorded in the transactions. For your particular question, decoding the hex is correct, but for the more general case of the input data representing the function call and its parameters you have to decode the interface described in this document.

Answer 8

In python, this is done using decode_function_input Contract method:

contract.decode_function_input(transaction.input)

see:

• https://github.com/ethereum/web3.py/blob/v4.9.1/docs/contracts.rst#utils
• https://github.com/ethereum/web3.py/blob/v4.9.1/web3/contract.py#L689

Answer 9

Consider using truffle and abi-decoder:

# compile contracts to generate ABIs
truffle compile

# let's do it from truffle console
truffle console

const abiDecoder = require('abi-decoder');

# take ABIs of required contracts
const { abi: abi1 } = require('./build/contracts/sc1.json');
const { abi: abi2 } = require('./build/contracts/sc2.json');
..

# register ABIs
abiDecoder.addABI(abi1);
abiDecoder.addABI(abi2);
..

# take 'TX data' of transaction & decode it (take for example the first transaction in  100th block)

let input = (await web3.eth.getTransactionFromBlock(100, 0)).input

abiDecoder.decodeMethod(input);

/* result
{
  name: 'request',
  params: [
    { name: '_control', value: 'control', type: 'string' },
    { name: '_tId', value: 'tid', type: 'string' },
    { name: '_number', value: 'inumber', type: 'string' }
  ]
}
*/

Answer 10

I am using "web3": "^1.6.1",

const data = await web3.eth.getTransaction(txHash);
return web3.eth.abi.decodeParameters(
      // ERC20 transfer method args
      [
        { internalType: 'address', name: 'recipient', type: 'address' },
        { internalType: 'uint256', name: 'amount', type: 'uint256' },
      ],
      `0x${txData.input.substring(10)}`
    );

The first 4 bytes of input is method's signature

output:

 {
    "0": "0x45d8253c7980d5718C5Fa3626d446886Fd857CfE",
    "1": "160750000000000000000",
    "__length__": 2,
    "recipient": "0x45d8253c7980d5718C5Fa3626d446886Fd857CfE",
    "amount": "160750000000000000000"
  }

Docs: https://web3js.readthedocs.io/en/v1.2.11/web3-eth-abi.html#decodeparameters

Answer 11

Using tenderly is a good option. If you add a verified contract (or have the abi/sources to add to tenderly directly), you can supply raw transaction data and run a simulation with it, and it will show you what the input decodes as.

Answer 12

This is slightly off topic, but for those who are looking to decode topic data like I was, here is an example of how to do it for if your topic is an address:

web3.eth.abi.decodeParameter("address", event.topics[1])

Where topics[1] was an address.