[SDK] @TODO: the returned hash did not match

[everdimension]

Team or Project

No response

Select the SDK

JavaScript

Environment

Mainnet

Issue Description

This is literally an error returned by the lib:
https://github.com/zksync-sdk/zksync-ethers/blob/dcbb6636e26656283e954b31f288f51bc25b9639/src/provider.ts#L996

Well thanks for the detailed explanation. Why doesn't it match?
And how come node successfully accepted such transaction?

I faced similar error in ethers@v5 before: #508

Now I updated to ethers@v6 and I have this error again.

Expected Behavior

¯\_(ツ)_/¯

Code Example

Something like this:

export function serializePaymasterTx({
  transaction,
  signature,
}: {
  transaction: zkSyncTypes.TransactionLike;
  signature: string;
}) {
  invariant(
    transaction.customData,
    'This method is intended for "paymaster" transactions (customData is expected)'
  );
  const rawTransaction = zkSyncUtils.serializeEip712(
    {
      ...transaction,
      customData: { ...transaction.customData, customSignature: signature },
    },
    signature
  );
  return rawTransaction;
}


async function sendTransaction() {
  const typedData = createTypedData(transaction);
  const signature = await this.signTypedData_v4({
    context,
    params: { typedData },
  });
  const rawTransaction = serializePaymasterTx({
    transaction,
    signature,
  });
  
  return await this.sendSignedTransaction({
    context,
    params: { serialized: rawTransaction },
  });
}

Repo Link (Optional)

No response

[gleenai[bot]]

It seems like you're encountering an issue where the transaction hash returned by the zksync-ethers library does not match the expected value. This issue might be related to how the transaction data is being serialized or signed.

Here are a few steps you can take to troubleshoot and potentially resolve this issue:

1. Verify Serialization and Signing: Ensure that the transaction is being serialized and signed correctly. The discrepancy in the hash could be due to how the data is structured or encoded before signing.

2. Check SDK Versions: Since you've mentioned this issue occurred previously with ethers@v5 and persists in ethers@v6, ensure that all dependencies related to zksync-ethers and ethers are compatible and up-to-date.

3. Review Custom Data Handling: The error might be related to how customData and customSignature are handled. Double-check that these fields are being processed correctly in your serializePaymasterTx function.

4. Consult Documentation: For more detailed information on handling transactions with custom data in ZKsync, you might find additional insights or similar cases in the ZKsync developers discussions on Github.

If these steps do not resolve the issue, consider providing more details such as the exact error message and transaction details to the ZKsync developers community for further assistance.

Your feedback helps us serve you better. If this fully addresses your question, please give it a thumbs up. If it doesn't, please give it a thumbs down. This will inform the community and team so we can improve our support.

[cytadela8]

Hi, this seems to be a bug in zksync-ethers. Please tell me the exact version of zksync-ethers you are using? Could you also provide a full reproduction example? I believe it may matter how you are calling zksync-ethers to send the transaction and this is not shown in the provided code example.

[everdimension]

"zksync-ethers": "^6.15.2"

I'm using the broadcastTransaction method

[everdimension]

import { Provider as ZksProvider } from 'zksync-ethers';

function sendSignedTransaction({ params: { serialized } }) {
  const provider = new ZksProvider(nodeUrl);
  const transactionResponse = await provider.broadcastTransaction(
    serialized
  );
  const safeTx = removeSignature(transactionResponse);
  return safeTx;
}

[everdimension]

This method also has other problems by the way: zksync-sdk/zksync-ethers#224

[danijelTxFusion]

The EIP712 transaction is not constructed correctly and that is why hashes don't match. Here is the updated example for minimal changes that works on Sepolia:

const provider = Provider.getDefaultProvider(types.Network.Sepolia);
const PRIVATE_KEY = process.env.PRIVATE_KEY;
const wallet = new Wallet(PRIVATE_KEY, provider);

function serializePaymasterTx(
  {transaction, signature}: { transaction: types.TransactionLike; signature: string; }
) {
    return utils.serializeEip712(
      {
        ...transaction,
        customData: {...transaction.customData, customSignature: signature},
      },
        signature
    );
}

async function sendTransaction(transaction: types.TransactionLike) {
  const signer = new EIP712Signer(new ethers.Wallet(PRIVATE_KEY), Number((await provider.getNetwork()).chainId));
  const signature = await signer.sign(transaction)

  const rawTransaction = serializePaymasterTx({
       transaction,
       signature,
   });

  return await provider.broadcastTransaction(rawTransaction);
}


const tokenAddress = '0x927488F48ffbc32112F1fF721759649A89721F8F'; // Crown token which can be minted for free
const paymasterAddress = '0x13D0D8550769f59aa241a41897D4859c87f7Dd46'; // Paymaster for Crown token

const tx = await sendTransaction({
  chainId: (await provider.getNetwork()).chainId,
  from: wallet.address,
  to: '0x81E9D85b65E9CC8618D85A1110e4b1DF63fA30d9',
  value: ethers.parseEther('0.01'),
  nonce: await wallet.getNonce(),
  gasLimit: 200_000n,
  maxFeePerGas: 250_000_000_000n,
  customData: {
    paymasterParams: utils.getPaymasterParams(paymasterAddress, {
      type: 'ApprovalBased',
      token: tokenAddress,
      minimalAllowance: 1,
      innerInput: new Uint8Array(),
    })
  }
})
const receipt = await tx.wait();
console.log(receipt);

output:

TransactionReceipt {
  provider: Provider { _contractAddresses: {} },
  to: '0x81E9D85b65E9CC8618D85A1110e4b1DF63fA30d9',
  from: '0x16939aA8E0A7E27D0c5314701d76c3BD68c3a946',
  contractAddress: null,
  hash: '0x69da72a8a5e355c5a4fb15a65e8f3f8e4161e130c33ee341a3e5885782265f93',
  index: 0,
  blockHash: '0x3cefe6b8d464138ba70d45cf6b9abd28b06ac44b49c5b88f0be7e3ae928a2f8d',
  blockNumber: 4282581,
  logsBloom: '0x00000000000400040000000010000000000000000000000000000000000000000000000000000000800000100000000000000000000000000000000000200000000000002000040000000008000000000000004000000000000000000000080000000000040000000000000000000000000000000000000000000010000000000000000000000000000004000000000000000000080000000000000000000000020000000000140000000000000000000000000000000000000000000000000000000002009000000000000000000800000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000',
  gasUsed: 154852n,
  blobGasUsed: undefined,
  cumulativeGasUsed: 0n,
  gasPrice: 25000000n,
  blobGasPrice: undefined,
  type: 113,
  status: 1,
  root: undefined,
  l1BatchNumber: undefined,
  l1BatchTxIndex: undefined,
  l2ToL1Logs: []
}

The easiest way is to utilize EIP712Signer. If that does not work for you, there is also static method Eip712Signer.getSignedDigest that returns the hash of the typed data. You just need to sign the hash to get the signature of the typed data.

[everdimension]

The EIP712 transaction is not constructed correctly

What's not correct?

Here's the code for createTypedData:

createTypedData

import type { types as zkSyncTypes } from 'zksync-ethers';
import { EIP712Signer, utils as zkSyncUtils } from 'zksync-ethers';
import { invariant } from 'src/shared/invariant';
import { normalizeChainId } from 'src/shared/normalizeChainId';

/**
 * Creates an "EIP-712 transaction": a TypedData object
 * that the user signs. The signature will be used when serializing the TransactionRequest
 */
export function createTypedData(transaction: zkSyncTypes.TransactionRequest) {
  invariant(
    Boolean(transaction.customData),
    'createTypedData expects a transaction with paymaster data'
  );
  const { chainId } = transaction;
  invariant(chainId, 'ChainId missing from TransactionRequest');
  const chainIdAsIntString = String(parseInt(normalizeChainId(chainId)));
  return {
    types: {
      Transaction: zkSyncUtils.EIP712_TYPES.Transaction,
      EIP712Domain: [
        { name: 'name', type: 'string' },
        { name: 'version', type: 'string' },
        { name: 'chainId', type: 'uint256' },
      ],
    },
    domain: {
      name: 'zkSync',
      version: '2',
      chainId: chainIdAsIntString,
    },
    primaryType: 'Transaction',
    message: EIP712Signer.getSignInput(transaction),
  };
}

I tried using the signer as you suggested:

const eip712Signer = new EIP712Signer(
  this.getOfflineSigner(),
  Number(chainId)
);
const signatureFromSigner = await eip712Signer.sign(transaction);

The resulting signatureFromSigner is exactly the same signature as I've been getting

I still get the "TODO" error about hash

[sarahschwartz]

@everdimension are you able to provide a repository for a full reproduction?

Edit: You may also find the WebAuthn tutorial helpful, as it has a full example of using the EIP712 Signer (with zksync-ethers 5 though) : https://code.zksync.io/tutorials/signing-transactions-with-webauthn/building-the-frontend#webauthn-utils
(full code here: https://github.com/zkSync-Community-Hub/community-code/tree/main/code/webauthn/frontend)

[everdimension]

@sarahschwartz
Thank you, but it will be of no help, since the code used to work with zksync-ethers v5. The problem is with v6

are you able to provide a repository for a full reproduction?

Yes, you can see the code here: https://github.com/zeriontech/zerion-wallet-extension/blob/b01060410b86ec199900a48bf9d347fbeea6f6ae/src/background/Wallet/Wallet.ts#L1183-L1213
If you want to try to run it, you'll need to install the local extension build and then try Sending or Swapping on ZERO network

[everdimension]

@danijelTxFusion Ping, can you please take a look
I've dug more into zksync-ethers internals and can't find anything obvious for why this issue is happening

[danijelTxFusion]

Sure I will check

[everdimension]

I have created a full reproduction project:
https://github.com/everdimension/zksync-zero-paymaster-tx

It created a basic Send transaction and uses zksync paymaster api

The "wrong hash" error is reproduced:

@cytadela8 @danijelTxFusion Please check it out

[everdimension]

I have found the issue.

EIP712Signer.getSignInput has a bug where it incorrectly fallbacks zero maxPriorityFeePerGas to maxFeePerGas

This produces wrong hash

The issue didn't happen in zksync-ethers@v5 because zero value looked like 0x0 or { "type": "BigNumber", "hex": "0x00" } and so the || operator didn't fall through

In v6, value is now a BigInt 0n and this leads to the bug

I've created a PR with the fix: zksync-sdk/zksync-ethers#228