ecrecover is problematically hardcoded to pre-EIP-155 transactions

[cyrusadkisson]

ethereumjs-utils' ecrecover function rejects any attempt to use v = anything other than 27 or 28 which means it only supports pre-EIP-155 transactions. This is self-evidently sub-optimal.

[cyrusadkisson]

At least, I think this is what's happening?

var v = 45; // goerli (5 * 2 + 35)
var publicKey = ecrecover(hash, v, r, s);
Uncaught Error: Invalid signature v value
    at ecrecover (node_modules/ethereumjs-util/dist/signature.js:50:15)

Any help would be appreciated.

[acolytec3]

Can you provide the actual inputs you're passing to ecrecover here (and/or the overall code snippet for the transaction these values are derived from)? Our tests for this function have a variety of values for v other than 27/28 and it does not generate an error like you describe.

[jochem-brouwer]

In our ecrecover method we have an optional field chainId which you should use in case that v is neither 27 or 28. (So, for Goerli, use chainId=BigInt(5)). This will internally convert v to the right value (it can only be 0 or 1) which we then feed into secp256k1 to get the sender public key.

[jochem-brouwer]

var v = 45; // goerli (5 * 2 + 35)
var publicKey = ecrecover(hash, v, r, s, BigInt(5));

This should do the trick.

[cyrusadkisson]

var digestHashInputToTheSigningAlgorithm = 0xee3a667ed717a89d2012240dc28760ab4df39ab6949267aab31cebc4a33ce735;
var v = 45;
var our_r_and_s = "0x012345678901234567890123456789012345678901234567890123456789012";
var r = toBuffer(our_r_and_s);
var s = toBuffer(our_r_and_s);
var hash = toBuffer(digestHashInputToTheSigningAlgorithm);
var publicKey = ecrecover(hash, v, r, s, BigInt(5));
Uncaught Error: invalid type
    at toBuffer (node_modules/ethereumjs-util/dist/bytes.js:168:11)
    at toType (node_modules/ethereumjs-util/dist/types.js:56:41)
    at calculateSigRecovery (node_modules/ethereumjs-util/dist/signature.js:34:42)
    at ecrecover (node_modules/ethereumjs-util/dist/signature.js:48:22)

[acolytec3]

I think if you make var digestHashInputToTheSigningAlgorithm = 0xee3a667ed717a89d2012240dc28760ab4df39ab6949267aab31cebc4a33ce735 -- var digestHashInputToTheSigningAlgorithm = "0xee3a667ed717a89d2012240dc28760ab4df39ab6949267aab31cebc4a33ce735"

It should work. Ensure that digestHashInputToTheSigningAlgorithm is a hex string and not an integer. If not, let me know. I'm constructing this from memory since we've switched over to uint8Array our master branch so I'll need to revert to the existing published code to verify the changes since we don't use toBuffer anymore internally.

[cyrusadkisson]

Thanks, but same result. "invalid type"

[acolytec3]

Try this:

  const digestHashInputToTheSigningAlgorithm =
    '0xee3a667ed717a89d2012240dc28760ab4df39ab6949267aab31cebc4a33ce735'
  const v = BigInt(45)
  const our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
  const r = toBuffer(our_r_and_s)
  const s = toBuffer(our_r_and_s)
  const hash = toBuffer(digestHashInputToTheSigningAlgorithm) //@ts-ignore
  const publicKey = ecrecover(hash, v, r, s, BigInt(5))
  console.log(publicKey)

I'm not able to reproduce your exact error but the above code works. The 2 issues that I found where 1) the digestHashInputToTheSigningAlgorithm should be a string and then v needs to be cast to a BigInt as erecover takes a bigint for v and not a number.

[cyrusadkisson]

Invalid type again, pasted exactly as above. Not sure what the disconnect is.

Why would v need to be a BigInt? It's typically within a single byte range (0-255) except for Sepolia.

[cyrusadkisson]

FYI, if I just hardcode mainnet (27) in there like this:

var publicKey = ecrecover(hash, 27, r, s);
console.log(publicKey); 

I no longer get an error and what appears to be a valid byte Buffer. So clearly ecrecover doesn't require a BigInt for v.

edit: if I try

var publicKey = ecrecover(hash, 0, r, s);
var publicKey = ecrecover(hash, 1, r, s);

I get the same results as 28 and 27, respectively. (yes, 0=28 and 1=27).

If I try 45 and 46, I get "invalid signature v value".
No values besides 0, 1, 27, and 28 seem to work at all.

[acolytec3]

What version of util are you using?

v is a BigInt in the latest release of @ethereumjs/util so if you pass in a number you will get an error like TypeError: Cannot mix BigInt and other types, use explicit conversions.

I used your script exactly in a pure JS file and got the above error.

[cyrusadkisson]

I'm using the stock npm repos. Here's my full list of installs.

├── @ethereumjs/[email protected]
├── @ethereumjs/[email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
└── [email protected]

[acolytec3]

Several of those are quite out of date. ethereumjs-abi is deprecated, and ethereumjs-tx and ethereumjs-util have been switched to namespaced versions as @ethereumjs/tx and @ethereumjs/util. Try updating to the latest versions of the noted namespaced versions and let me know what errors you get.

[cyrusadkisson]

Updated everything and restarted node console. Still "invalid type" when trying to provide a BigInt for v.
And I get "Invalid signature v value" for everything except 0, 1, 27 and 28.

├── @ethereumjs/[email protected]
├── @ethereumjs/[email protected]
├── @ethereumjs/[email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
└── [email protected]

Here is the full script:

var { ecsign, ecrecover, pubToAddress, toBuffer } = require('ethereumjs-util');

// Given values
var contractAddress = "0xc5edca3ebf230f0df3d75b3138d733fe58d234a0";
var unwrapTxValue = "1000000000000000";
var unwrapTxGasLimit = 1000000;
var unwrapTxGasPrice = "50000000000";

// Given values for col and row
var col = 16;
var row = 16;

// Generate the data for the transaction using the function signature and parameters
var unwrapTxData = web3.eth.abi.encodeFunctionCall({
    name: 'unwrap',
    type: 'function',
    inputs: [{
        type: 'uint8',
        name: 'col'
    },{
        type: 'uint8',
        name: 'row'
    }]
}, [col, row]);

var parameters = [
    contractAddress,
    unwrapTxValue,
    unwrapTxGasLimit,
    unwrapTxGasPrice,
    unwrapTxData
];

// Encode the parameters
var encodedParameters = web3.eth.abi.encodeParameters(
    ['address', 'uint256', 'uint256', 'uint256', 'bytes'], 
    parameters
);

// Hash the encoded parameters
var digestHashInputToTheSigningAlgorithm = web3.utils.keccak256(encodedParameters);

var v = BigInt(45)
var our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
var r = toBuffer(our_r_and_s)
var s = toBuffer(our_r_and_s)
var hash = toBuffer(digestHashInputToTheSigningAlgorithm)
var publicKey = ecrecover(hash, v, r, s, BigInt(5))
console.log(publicKey)

[acolytec3]

Is the first line still possibly the issue? var { ecsign, ecrecover, pubToAddress, toBuffer } = require('ethereumjs-util'); -- you're still importing ethereumjs-util instead of @ethereumjs/util. I created a brand new project, installed the latest version of @ethereumjs/util and ran the below script and it worked just fine.

const { ecrecover, toBuffer } = require('@ethereumjs/util');

var digestHashInputToTheSigningAlgorithm = '0xee3a667ed717a89d2012240dc28760ab4df39ab6949267aab31cebc4a33ce735';
var v = BigInt(45);
var our_r_and_s = "0x012345678901234567890123456789012345678901234567890123456789012";
var r = toBuffer(our_r_and_s);
var s = toBuffer(our_r_and_s);
var hash = toBuffer(digestHashInputToTheSigningAlgorithm);
var publicKey = ecrecover(hash, v, r, s, BigInt(5));
console.log(publicKey)

[cyrusadkisson]

No. Still doesn't work. Same as before.

Are you installing from public repos? What are your package versions?

[acolytec3]

Here's an example repo with the most recent version of @ethereumjs/util installed.

Just run node script.js from the repo root.

[jochem-brouwer]

This should work on your install with ethereumjs-util:

var { ecsign, ecrecover, pubToAddress, toBuffer } = require('ethereumjs-util');

var digestHashInputToTheSigningAlgorithm = Buffer.from('ee3a667ed717a89d2012240dc28760ab4df39ab6949267aab31cebc4a33ce735', 'hex')

var v = 45
var our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
var r = toBuffer(our_r_and_s)
var s = toBuffer(our_r_and_s)
var hash = toBuffer(digestHashInputToTheSigningAlgorithm)
var publicKey = ecrecover(hash, v, r, s, 5)
console.log(publicKey)

Do not use BigInts in your version, use "normal" numbers vor v and chainId (chain id is thus 5 here).

[jochem-brouwer]

And this works for me for:

├── @ethereumjs/[email protected]
├── [email protected]

var { ecsign, ecrecover, pubToAddress, toBuffer } = require('ethereumjs-util');
var Web3 = require('web3')
var web3 = new Web3()

// Given values
var contractAddress = "0xc5edca3ebf230f0df3d75b3138d733fe58d234a0";
var unwrapTxValue = "1000000000000000";
var unwrapTxGasLimit = 1000000;
var unwrapTxGasPrice = "50000000000";

// Given values for col and row
var col = 16;
var row = 16;

// Generate the data for the transaction using the function signature and parameters
var unwrapTxData = web3.eth.abi.encodeFunctionCall({
    name: 'unwrap',
    type: 'function',
    inputs: [{
        type: 'uint8',
        name: 'col'
    },{
        type: 'uint8',
        name: 'row'
    }]
}, [col, row]);

var parameters = [
    contractAddress,
    unwrapTxValue,
    unwrapTxGasLimit,
    unwrapTxGasPrice,
    unwrapTxData
];

// Encode the parameters
var encodedParameters = web3.eth.abi.encodeParameters(
    ['address', 'uint256', 'uint256', 'uint256', 'bytes'], 
    parameters
);

// Hash the encoded parameters
var digestHashInputToTheSigningAlgorithm = web3.utils.keccak256(encodedParameters);

var v = 45
var our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
var r = toBuffer(our_r_and_s)
var s = toBuffer(our_r_and_s)
var hash = toBuffer(digestHashInputToTheSigningAlgorithm)
var publicKey = ecrecover(hash, v, r, s, 5)
console.log(publicKey)

I.e. do not use BigInts but use normal numbers.

[cyrusadkisson]

Thanks.

That "works" but maybe not? The resulting byte sequence I get for v=45 is identical to v=27. That doesn't seem right, does it?

<Buffer 6d a6 6f 0e d3 b6 a6 a1 c6 c4 93 49 94 0c b2 11 42 26 3b ee 5a 07 c3 8a 02 80 06 4b ee 33 79 da 2f 90 d7 db 61 a9 a7 d9 95 8f fb c2 b2 3c 66 b3 78 81 ... 14 more bytes>

[jochem-brouwer]

If I take this code

var { ecsign, ecrecover, pubToAddress, toBuffer } = require('ethereumjs-util');
var Web3 = require('web3')
var web3 = new Web3()

// Given values
var contractAddress = "0xc5edca3ebf230f0df3d75b3138d733fe58d234a0";
var unwrapTxValue = "1000000000000000";
var unwrapTxGasLimit = 1000000;
var unwrapTxGasPrice = "50000000000";

// Given values for col and row
var col = 16;
var row = 16;

// Generate the data for the transaction using the function signature and parameters
var unwrapTxData = web3.eth.abi.encodeFunctionCall({
    name: 'unwrap',
    type: 'function',
    inputs: [{
        type: 'uint8',
        name: 'col'
    },{
        type: 'uint8',
        name: 'row'
    }]
}, [col, row]);

var parameters = [
    contractAddress,
    unwrapTxValue,
    unwrapTxGasLimit,
    unwrapTxGasPrice,
    unwrapTxData
];

// Encode the parameters
var encodedParameters = web3.eth.abi.encodeParameters(
    ['address', 'uint256', 'uint256', 'uint256', 'bytes'], 
    parameters
);

// Hash the encoded parameters
var digestHashInputToTheSigningAlgorithm = web3.utils.keccak256(encodedParameters);

var v = (45)
var our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
var r = toBuffer(our_r_and_s)
var s = toBuffer(our_r_and_s)
var hash = toBuffer(digestHashInputToTheSigningAlgorithm)
var publicKey = ecrecover(hash, v, r, s, 5)
console.log(publicKey.toString('hex'))

I get 6da66f0ed3b6a6a1c6c49349940cb21142263bee5a07c38a0280064bee3379da2f90d7db61a9a7d9958ffbc2b23c66b37881692d599e90141510c822d09b97e4

I change the final lines to:

var v = (27)
var our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
var r = toBuffer(our_r_and_s)
var s = toBuffer(our_r_and_s)
var hash = toBuffer(digestHashInputToTheSigningAlgorithm)
var publicKey = ecrecover(hash, v, r, s, 5)
console.log(publicKey.toString('hex'))

I get an error. Which should be, due to EIP-155. (Note: var v = 27 instead of v = 45 before)

If I now remove the chainId 5 from ecrecover (single-to-last line)

var v = (27)
var our_r_and_s = '0x012345678901234567890123456789012345678901234567890123456789012'
var r = toBuffer(our_r_and_s)
var s = toBuffer(our_r_and_s)
var hash = toBuffer(digestHashInputToTheSigningAlgorithm)
var publicKey = ecrecover(hash, v, r, s)
console.log(publicKey.toString('hex'))

I again get 6da66f0ed3b6a6a1c6c49349940cb21142263bee5a07c38a0280064bee3379da2f90d7db61a9a7d9958ffbc2b23c66b37881692d599e90141510c822d09b97e4, which is expected, see https://eips.ethereum.org/EIPS/eip-155

[jochem-brouwer]

From EIP-155

[jochem-brouwer]

If you want to have a chat feel free to join our discord! 😄 https://discord.gg/FV4VnwXMG6

[cyrusadkisson]

Ugh. I'm just gonna use pre-eip-155 transactions. This is all too convoluted. (Not to mention solidity ecrecover can't handle Sepolia's chain id.)

In your opinions, do you think pre-eip-155 transactions are in any danger of ever being sunset?

[jochem-brouwer]

Do not use pre-155 transactions because these can be replayed along other chains

[cyrusadkisson]

Doesn't apply to my situation.

Do you think pre-eip-155 transactions could ever become invalid?

[cyrusadkisson]

Any thoughts here?

[cyrusadkisson]

Did I say something wrong?

[acolytec3]

Doesn't apply to my situation.

Do you think pre-eip-155 transactions could ever become invalid?

I'm not aware of another actively considered EIP that is contemplating sunsetting the earlier signature scheme so should be fine as long as you're not concerned about replay on other chains.