Web3.py – How Can the Transaction Hash / Block Hash of an Already Deployed Contract Be Retrieved?

blockstransactionsweb3.py

If you use Web3.py to deploy a Solidity contract to the blockchain, you can retrieve a transaction hash, like this:

tx_hash = w3.eth.sendRawTransaction(signed.rawTransaction)

Once you have that tx_hash, you can retrieve a transaction receipt, like this:

tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash)

However, I haven't been able to find a straightforward way to retrieve that information for a contract that I didn't deploy (or that I deployed at some point in the past and didn't record).

Couple of notes:

There could be multiple transactions across multiple blocks for that contract.
I'm looking for a solution using Web3 — I'd prefer not to traverse the entire blockchain or go to Etherscan and look up the information.

I would like to get an array of either:

all the block numbers that contain a transaction for a given contract
all the transaction receipts for a given contract

after the contract has been deployed. Is that possible?

For example, let's imagine that I wanted to find all of the transaction receipts for a smart contract deployed on the Ropsten test network.

Let's use the helloWorld contract deployed at this address: 0xb1Afb360F9ba99883166236a4b2DdAa9e3ff397a

This contract has been verified on Etherscan, so its ABI is available. You can see it on Etherscan here: https://ropsten.etherscan.io/address/0xb1afb360f9ba99883166236a4b2ddaa9e3ff397a#code

The following Python code will allow you to instantiate the contract, and call functions defined in the ABI:

abi = '''
[{"constant":false,"inputs":[{"name":"_wordsToSay","type":"string"}],"name":"sayAnything","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"sayHello","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]
'''

contract_address = "0xb1Afb360F9ba99883166236a4b2DdAa9e3ff397a"
contract = w3.eth.contract(address=contract_address, abi=abi)

pprint.pprint(contract.functions.sayHello().call())

The only other attributes I have been able to retrieve are the address and the ABI.

Is there any way to retrieve the block numbers or transaction hashes for an already deployed contract?

Best Answer

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.

Related Solutions

[Ethereum] How to call a function in deployed contract on Ropsten Testnet when I don’t have ABI and source code

There is (almost) no way to get the ABI if you only have the transaction hash and/or contract address.

I said almost because it is possible to reverse-engineer the contract. At least in theory. Reverse-engineering is always a difficult process and it might not work. There are some tools which attempt to do it for you but I don't really know how accurate they are.

Some more info on reverse-engineering: Is there a way to extract ABI from a deployed contract?

Just to clarify some confusion in an another answer's comments: verifying your code on Etherscan isn't really a Ethereum term. It's only functionality which was (possibly) invented by Etherscan team. It's a handy feature but it's not necessary in any way. You can publish your code in the blockchain without providing the source code to anyone.

Etherscan – How to Get Implementation Contract Address from Proxy Contract Address

Most proxy contracts typically have a public variable defined as a:

address public implementation;

Which defines the address of the implementation contract. You could then call it as a view function in python, with something like:

proxy_contract = web3.eth.contract(address=address, abi=abi_string)
implementation_contract_address = proxy_contract.functions.implementation.call()

However, this contract, in particular, doesn't have an implementation function and has some private functions.

Here is the code for their proxy contract where they call the delegatecall to the implementation:

bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation() internal override view returns (address impl) {
        bytes32 slot = _IMPLEMENTATION_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            impl := sload(slot)
        }
    }

So you'd have to read directly off the storage of the blockchain to understand what _IMPLEMENTATION_SLOT is. We also need to know some yul/assembly to understand what's going on.

sload(p) loads the value that is stored in storage at location p. In this contract, this means the implementation contract address is stored at location 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc in memory.

We can confirm this, by looking at the _setImplementation method, where it stores the new implementation address with sstore (more Yul code, that sets a value at a location in storage).

function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "UpgradeableProxy: new implementation is not a contract");

        bytes32 slot = _IMPLEMENTATION_SLOT;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            sstore(slot, newImplementation)
        }
    }

So, all we have to do to read this, is read the address that is located in the storage of this contract at the location defined in _IMPLEMENTATION_SLOT.

We can find this with:

def main():
    web3 = Web3(Web3.HTTPProvider("https://bsc-dataseed2.defibit.io/"))
    impl_contract = Web3.toHex(
        web3.eth.get_storage_at(
            contract_address,
            "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
        )
    )
    print(impl_contract)

To which we get: 0x000000000000000000000000ba5fe23f8a3a24bed3236f05f2fcf35fd0bf0b5c

Which we then just undo the 0 padding, to get the address of: 0xba5fe23f8a3a24bed3236f05f2fcf35fd0bf0b5c. Which is indeed the implementation contract.

Edit

It should be noted, that a lot of contracts will use this IMPLEMENTATION_SLOT, as it follows the guidelines of the ERC1967

Best Answer

Related Solutions

[Ethereum] How to call a function in deployed contract on Ropsten Testnet when I don’t have ABI and source code

Etherscan – How to Get Implementation Contract Address from Proxy Contract Address

Edit

Related Topic