¿Cómo decodificar los datos de entrada de una transacción?

Puede hacer web3.toAscii(transactionID.input)para devolver los datos en formato legible.

Leer web3.toAscii

Para decodificar datos, puede usar una biblioteca llamada abi-decoder

Deberá proporcionar un ABI para el contrato inteligente que desea decodificar, luego simplemente pegue los datos de entrada. Muy simple.

La única desventaja ocurriría si sus datos de entrada fueran "Constructor" de creación de contrato inteligente, entonces, en ese caso, tendrá que cambiar la biblioteca para adaptarse a eso.

Si ha oído hablar de la biblioteca ethers js , proporciona una función fantástica llamada parseTransaction , la encontré después de una búsqueda muy larga ya que no se mencionó en ningún foro en línea y todavía estoy aprendiendo mucho sobre esto.

Pero descubrí que es lo mejor para decodificar cualquier tipo de contrato y llamada de función asociada.

    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])
          });        
    })();

Herramientas de interfaz de usuario

• cleanunicorn.github.io/santoku
• etid.wtd.ru
• ethtx.info
• moesif.com/solidity-abi-hex-decodificador/decodificación

Tenga en cuenta que para estos necesitará el ABI del contrato.

Paquetes de nodos

• @ethersproject/abi (parte del paquete paraguas ethers )
• abi-decodificador
• ethereum-entrada-datos-decodificador

Recomendación

Use @ethersproject/abi, es el enfoque más seguro de todos. Ethers ha sido probado en batalla en miles de proyectos de Ethereum y es probable que no haya ningún error en su implementación de codificación/descodificación ABI.

Hemos hecho una buena herramienta para decodificar. Simplemente pegue el hash de la transacción en la entrada y obtenga el resultado. Verifíquelo Funciona con Mainnet, Kovan, Ropsten y Rinkeby, pero el código del contrato debe verificarse en Etherscan. Usamos la API de Etherscan para obtener datos de transacciones y contratos, y web3 para la decodificación.

Esta biblioteca de JavaScript/Node.js puede decodificar datos de entrada de contratos inteligentes y datos de entrada de creación de contratos dado el JSON abi:

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

Una definición completa de lo que está tratando de decodificar (el campo de datos de entrada) está aquí: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI . Es difícil, pero pude escribir algo de C ++ que analiza completamente los argumentos de función tal como se registran en las transacciones. Para su pregunta particular, decodificar el hexadecimal es correcto, pero para el caso más general de los datos de entrada que representan la llamada a la función y sus parámetros, debe decodificar la interfaz descrita en este documento.

En python, esto se hace usando el método de contrato decode_function_input:

contract.decode_function_input(transaction.input)

ver:

• 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

Considere usar truffle y 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' }
  ]
}
*/

estoy usando"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)}`
    );

Los primeros 4 bytes de entrada son la firma del método

producción:

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

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

Usar tiernamente es una buena opción. Si agrega un contrato verificado (o tiene las fuentes/abi para agregar directamente), puede proporcionar datos de transacción sin procesar y ejecutar una simulación con él, y le mostrará cómo se decodifica la entrada.