Recover public key from contract deployment transaction

I’m trying to get the public key of a user during the contract deployment but I’m not sure if it’s possible with ethers.js. I’d like to solve it using only this package as I don’t want to bloat my react builds with web3.js. I’m using ethers 4.0.42.

I took a deep dive into your source code, ECDSA and looked at a related issue and came up with the following code.

I think my biggest issue is to get the signing hash. So here’s my attempt:

// before: contract = await factory.deploy(...);

// get the signing hash
const deployTx = contract.deployTransaction;
const txData = {
  gasPrice: deployTx.gasPrice,
  gasLimit: deployTx.gasLimit,
  value: deployTx.value,
  nonce: deployTx.nonce,
  data: deployTx.data,
  chainId: deployTx.chainId
};
const tx = await ethers.utils.resolveProperties(txData);
const rawTx = ethers.utils.serializeTransaction(tx); // returns RLP encoded tx
const msgHash = ethers.utils.keccak256(rawTx); // as specified by ECDSA

Note that msgHash is the signing hash.

// get flat signature for recovery
const expandedSig = {
  r: deployTx.r,
  s: deployTx.s,
  recoveryParam: 0, // not really sure what this does
  v: deployTx.v // i think this value is only needed because of EIP155 (CHAIN_ID * 2 + 35 or 36)
};
const signature = ethers.utils.joinSignature(expandedSig);


const msgBytes = ethers.utils.arrayify(msgHash); // create binary hash
const recoveredPubKey = ethers.utils.recoverPublicKey(
  msgBytes,
  signature
);
const recoveredAddress = ethers.utils.recoverAddress(msgBytes, signature);

Unfortunately both the recoveredPubKey and the recoveredAddress are false.

[lastmjs]

I’m having a hard time getting the public key from a transaction response on ropsten. Would anyone mind giving me an example of how to do this with a simple transaction response, just a normal transaction from an external account?

Here’s the function from my application:

async function deriveEthereumPublicKeyFromEthereumAddress(ethereumAddress: string): Promise<string> {

    console.log('ethereumAddress', ethereumAddress);

    const etherscanProvider = new ethers.providers.EtherscanProvider('ropsten');

    const transactionResponses: ReadonlyArray<ethers.providers.TransactionResponse> = await etherscanProvider.getHistory(ethereumAddress);

    const aSignedTransaction: Readonly<ethers.providers.TransactionResponse> | undefined = transactionResponses.find((transactionResponse: Readonly<ethers.providers.TransactionResponse>) => {
        return transactionResponse.from === ethereumAddress;
    });

    if (aSignedTransaction === undefined) {
        throw new Error(`The Ethereum address has no signed transactions`);
    }

    const provider = ethers.getDefaultProvider('ropsten');

    const transactionResponse = await provider.getTransaction(aSignedTransaction.hash);

    console.log('transactionResponse', transactionResponse);

    const signature: string = ethers.utils.joinSignature({
        r: transactionResponse.r,
        s: transactionResponse.s,
        v: transactionResponse.v
    });

    console.log('signature', signature);

    const txData = {
        gasPrice: transactionResponse.gasPrice,
        gasLimit: transactionResponse.gasLimit,
        value: transactionResponse.value,
        nonce: transactionResponse.nonce,
        data: transactionResponse.data,
        chainId: transactionResponse.chainId
    };

    const transaction = await ethers.utils.resolveProperties(txData);
    const rawTransaction = ethers.utils.serializeTransaction(transaction);
    const hashedTransaction = ethers.utils.keccak256(rawTransaction);
    const hashedTransactionBytes = ethers.utils.arrayify(hashedTransaction);
    
    console.log('hashedTransactionBytes', hashedTransactionBytes);

    const publicKey: string = ethers.utils.recoverPublicKey(hashedTransactionBytes, signature)

    console.log('publicKey', publicKey);

    const originalAddress: string = ethers.utils.recoverAddress(hashedTransactionBytes, signature);

    console.log('originalAddress', originalAddress);

    return publicKey;
}

It doesn’t come out correctly, and I’m not sure why

[protortyp]

Perfect! Thanks for helping out 😃