[Ethereum] How to get the value of the transaction

blockspythonraw-transactiontransactionsweb3.py

I am using web3.py but I need help to know the value of the transaction sent.
I know that the information is stored in the input but how do I parse the string. I know nothing about ABI.
Here is the tx_hash = 0xb6a594e6e9579d76870d54618b8df25e6662a200f1d2f3c9e27f506e851fa092
and here is the input: 0xa9059cbb000000000000000000000000453a0961ed6badd98fc396b01ab9b5939d9e27f1000000000000000000000000000000000000000000000000000000000000000a

How do I get the value of the transaction in a simple value ?

Best Answer

New Answer (Based on comment)

To get the value of ERC20 tokens being transferred, you need to parse the input data of the transaction.

Per the standard, the transfer function looks as follows:

function transfer(address _to, uint256 _value) public returns (bool success)

This means that you must look for the final parameter in the input data. An example transaction can be seen here. In this example, the input data is as follows:

0xa9059cbb000000000000000000000000dfbc84ccac430f2c0455c437adf417095d7ad68e0000000000000000000000000000000000000000000000158b5ff8fb42b95000

0xa9059cbb

This is the hash of the method signature.

000000000000000000000000dfbc84ccac430f2c0455c437adf417095d7ad68e

This is the address where the tokens are being sent.

0000000000000000000000000000000000000000000000158b5ff8fb42b95000

This is the amount (in Hex) and is the value you are looking for. In this example, this comes out to 397.424645 tokens.

Original Answer

The value of the transaction is actually not in the input data, but rather in its own value field. If you know the hash, you can get the value.

>>> tx_data = web3.eth.getTransactionReceipt(tx_hash)
>>> print(tx_data["value"])
1000000000000000000

If you get the transaction receipt, the value field will be included in the output. That is the amount of Wei sent in the transaction.

Related Solutions

[Ethereum] How to decode input data from tx using python3

If you know the contract ABI, call data could be decoded using pyethereum:

from ethereum.abi import (
    decode_abi,
    normalize_name as normalize_abi_method_name,
    method_id as get_abi_method_id)
from ethereum.utils import encode_int, zpad, decode_hex

def decode_contract_call(contract_abi: list, call_data: str):
    call_data_bin = decode_hex(call_data)
    method_signature = call_data_bin[:4]
    for description in contract_abi:
        if description.get('type') != 'function':
            continue
        method_name = normalize_abi_method_name(description['name'])
        arg_types = [item['type'] for item in description['inputs']]
        method_id = get_abi_method_id(method_name, arg_types)
        if zpad(encode_int(method_id), 4) == method_signature:
            try:
                args = decode_abi(arg_types, call_data_bin[4:])
            except AssertionError:
                # Invalid args
                continue
            return method_name, args

[Ethereum] How to retrieve the transaction hash / block hash of a contract that has already been deployed

Since you're interested in arbitrary contracts that don't emit events, you'll have to scan each block. Additionally, to capture scenarios where the contract you're interested in is called by another contract (instead of an Externally Owned Account), you'll likely have to run a trace on each transaction.

Traces are non-standard (client-specific) mechanisms for peeking inside the EVM mechanics of a transaction. Infura does not support traces, AFAIK. So you'll almost certainly have to run a local node.

Web3.py only supports parity traces, currently, so I'd probably start there. Unfortunately they're not documented in web3.py docs at the moment. You would roughly do something like:

from web3.auto import w3
from web3.parity import Parity
Parity.attach(w3, 'parity)
trace_results = w3.parity.traceReplayBlockTransactions('latest')

You can find more parity trace methods in the web3py source.