Get method signature from contract rather than manually constructing

Question

Is there a way to get a method signature from the contract object (using Web3.py) rather than manually constructing it? I don't see a function in there that accomplishes this. It seems like something should be built-in.

I have always calculated the method signature manually using Web3.sha3 as seen below, but this requires me to manually type out the function params.

params = 'uint256,uint256,bytes,address[]'
method_signature = Web3.sha3(text=f"functionNameGoesHere({params})")[0:4]

The contract object already knows the ABI JSON, so shouldn't it be able to generate it for me?

It would be nice if I could do this:

function.method_signature

Since I can already do this:

function.abi

Note, I'm NOT trying to build a transaction to broadcast to the network. I'm trying to generate lots of function hashes from contracts given the contract object an ABI. And these contracts will change over time so I don't want to hard code anything.

Edit: I wrote this myself to do the job. It supports regular types as well as tuples. Would still prefer to use something built-in though.

def GetMethodSignature_GivenAbi(methodName, abi):
    params = ''
    for index, input in enumerate(abi['inputs']):
        if index > 0:
            params += ','

        if input['type'] == 'tuple':
            params += '('
            for index2, tupleComponent in enumerate(input['components']):
                if index2 > 0:
                    params += ','

                params += tupleComponent['type']

            params += ')'

        else:
            params += input['type']

    methodSignature = GetMethodSignature(methodName, params)
    return methodSignature

ABI simple example:

{
  'constant': False,
  'inputs': [
    {
      'name': 'name1',
      'type': 'uint256'
    },
    {
      'name': 'name2',
      'type': 'uint256'
    }
  ],
  'name': 'simpleFunction',
  'outputs': [

  ],
  'payable': False,
  'stateMutability': 'nonpayable',
  'type': 'function'
}

ABI tuple example:

{
  'constant': False,
  'inputs': [
    {
      'name': 'name1',
      'type': 'uint256'
    },
    {
      'name': 'name2',
      'type': 'uint256'
    },
    {
      'name': 'name3',
      'type': 'uint256'
    },
    {
      'components': [
        {
          'name': 'makerAddress',
          'type': 'address'
        },
        {
          'name': 'takerAddress',
          'type': 'address'
        },
        {
          'name': 'feeRecipientAddress',
          'type': 'address'
        },
        {
          'name': 'senderAddress',
          'type': 'address'
        },
        {
          'name': 'makerAssetAmount',
          'type': 'uint256'
        },
        {
          'name': 'takerAssetAmount',
          'type': 'uint256'
        },
        {
          'name': 'makerFee',
          'type': 'uint256'
        },
        {
          'name': 'takerFee',
          'type': 'uint256'
        },
        {
          'name': 'expirationTimeSeconds',
          'type': 'uint256'
        },
        {
          'name': 'salt',
          'type': 'uint256'
        },
        {
          'name': 'makerAssetData',
          'type': 'bytes'
        },
        {
          'name': 'takerAssetData',
          'type': 'bytes'
        },
        {
          'name': 'makerFeeAssetData',
          'type': 'bytes'
        },
        {
          'name': 'takerFeeAssetData',
          'type': 'bytes'
        }
      ],
      'name': 'order',
      'type': 'tuple'
    },
    {
      'name': 'name4',
      'type': 'bytes'
    },
    {
      'name': 'name5',
      'type': 'address[]'
    }
  ],
  'name': 'functionName',
  'outputs': [

  ],
  'payable': False,
  'stateMutability': 'nonpayable',
  'type': 'function'
}

Answer 1

A contract on a blockchain does not store method signatures, only hashes of method signatures.

This information is encoded in the EVM bytecode as "jump destinations" based on the method signature.

For everything else, you need ABI files, precompiled or compile yourself.

EtherScan collects contract source code and recompiles it when you "verify" the contract.

Answer 2

Given the ABI of a contract, you can generate the signature of every function in that contract:

signatures = {}
for func in [obj for obj in abi if obj['type'] == 'function']:
    name = func['name']
    types = [input['type'] for input in func['inputs']]
    signatures[name] = '{}({})'.format(name,','.join(types))

And then call Web3.sha3 with each one of these signatures.

This should allow you to handle contract changes programmatically.

---

If it makes it easier for you, then you can also create an array instead of a dictionary:

signatures = ['{}({})'.format(func['name'],','.join([input['type'] for input in func['inputs']])) for func in [obj for obj in abi if obj['type'] == 'function']]

Answer 3

I don't know if I understood correctly, You can get a function selector for a function in a smart contract like this.

Greeter = w3.eth.contract(abi=abi, bytecode=bytecode)
Greeter.functions.getTime().selector
>>>'0x557ed1ba'

Where getTime() is a public function of Smart contract.

if a function accepts arguments,then

Web3.sha3(text=f"setValue({'uint256'})")[0:4]
>>>HexBytes('0x55241077')

Greeter.functions.setValue(1364283634).selector
>>>'0x55241077'

You can also call the selector function on a deployed instance of a contract using its abi and address.