[General] Paymaster validation error

[4NNNN]

Environment

Testnet

Provide a brief description of the functionality you're trying to implement.

Paymaster.sol

After the basic account registry and module manager feature update, there's a error when a AAtransaction is passed from the paymaster checkvalidationpayment function. The below lines in the paymaster.sol is where the error hits !!

address registry = IModuleManager(moduleManager).accountRegistry();
require(IAccountRegistry(registry).isAccount(from), "INVALID_ACCOUNT");

What is the specific issue or error you're encountering?

Error: failed paymaster validation. error message: Error function_selector = 0x, data = 0x

Can you share the error messages or logs you're receiving, if any?

Error message :
reason: 'processing response error',
code: 'SERVER_ERROR',
body: '{"jsonrpc":"2.0","error":{"code":3,"message":"failed paymaster validation. error message: Error function_selector = 0x, data = 0x","data":"0x"},"id":54}\n',
error: Error: failed paymaster validation. error message: Error function_selector = 0x, data = 0x

Have you made any recent changes to the contract before encountering this issue?

This is how i'm calling the paymaster contract for a token minting process via the paymaster and the error hits when i run this script which basically calls paymasters validateandpayfortransaction function !!! Is there a problem with the way i'm encoding the paymaster params or ?? There's a similiar approach by porrco-rosso on implementing the account registry and module registry feature with the zksync AA contracts "https://github.com/porco-rosso-j/zksync-account-trade-limit/tree/main/src"

const erc20 = getToken(hre, emptyWallet);
const gasPrice = await provider.getGasPrice();
console.log(gasPrice)
// Encoding the "ApprovalBased" paymaster flow's input
const paymasterParams = utils.getPaymasterParams(PAYMASTER_ADDRESS, {
type: "ApprovalBased",
token: TOKEN_ADDRESS,
// set minimalAllowance as we defined in the paymaster contract
minimalAllowance: ethers.BigNumber.from(1),
// empty bytes as testnet paymaster does not use innerInput
innerInput: new Uint8Array(),
});
console.log(paymasterParams)
//const paymasterParamsHex = ethers.utils.hexlify(ethers.utils.toUtf8Bytes(JSON.stringify(paymasterParams)));
//console.log(paymasterParamsHex)
// Estimate gas fee for mint transaction
const gasLimit = await erc20.estimateGas.mint(emptyWallet.address, 5, {
customData: {
gasPerPubdata: utils.DEFAULT_GAS_PER_PUBDATA_LIMIT,
paymasterParams: paymasterParams,
},
});

console.log(gasLimit)
const fee = gasPrice.mul(gasLimit.toString());
console.log("Transaction fee estimation is :>> ", fee.toString());
console.log("after this")
console.log(Minting 5 tokens for empty wallet via paymaster...);
await (
await erc20.mint(emptyWallet.address, 5, {
// paymaster info
customData: {
paymasterParams: paymasterParams,
gasPerPubdata: utils.DEFAULT_GAS_PER_PUBDATA_LIMIT,
},
})
).wait();

console.log(
Paymaster ERC20 token balance is now ${await erc20.balanceOf( PAYMASTER_ADDRESS )}
);

Are there any external libraries or contracts that your contract interacts with?

https://github.com/porco-rosso-j/zksync-account-trade-limit/blob/main/src/aa-wallet/AccountRegistry.sol
https://github.com/porco-rosso-j/zksync-account-trade-limit/blob/main/src/aa-wallet/modules/ModuleManager.sol

Can you provide the relevant portions of your contract code where the issue is occurring?

function validateAndPayForPaymasterTransaction(
bytes32,
bytes32,
Transaction calldata _transaction
)
external
payable
onlyBootloader
returns (bytes4 magic, bytes memory context)
{
magic = PAYMASTER_VALIDATION_SUCCESS_MAGIC;
require(
_transaction.paymasterInput.length >= 4,
"The standard paymaster input must be at least 4 bytes long"
);
//address from = address(uint160(_transaction.from));

    //address registry = IModuleManager(moduleManager).accountRegistry();
    //require(IAccountRegistry(registry).isAccount(from), "INVALID_ACCOUNT");
    // By default we consider the transaction as accepted.
    

    bytes4 paymasterInputSelector = bytes4(
        _transaction.paymasterInput[0:4]
    );
    if (paymasterInputSelector == IPaymasterFlow.approvalBased.selector) {
        // While the transaction data consists of address, uint256 and bytes data,
        // the data is not needed for this paymaster
        (address token, uint256 amount, bytes memory data) = abi.decode(
            _transaction.paymasterInput[4:],
            (address, uint256, bytes)
        );

        // Verify if token is the correct one
        require(token == allowedToken, "Invalid token");

        // We verify that the user has provided enough allowance
        address userAddress = address(uint160(_transaction.from));

        address thisAddress = address(this);

        uint256 providedAllowance = IERC20(token).allowance(
            userAddress,
            thisAddress
        );
        require(
            providedAllowance >= PRICE_FOR_PAYING_FEES,
            "Min allowance too low"
        );

        // Note, that while the minimal amount of ETH needed is tx.gasPrice * tx.gasLimit,
        // neither paymaster nor account are allowed to access this context variable.
        uint256 requiredETH = _transaction.gasLimit *
            _transaction.maxFeePerGas;

        try
            IERC20(token).transferFrom(userAddress, thisAddress, amount)
        {} catch (bytes memory revertReason) {
            // If the revert reason is empty or represented by just a function selector,
            // we replace the error with a more user-friendly message
            if (revertReason.length <= 4) {
                revert("Failed to transferFrom from users' account");
            } else {
                assembly {
                    revert(add(0x20, revertReason), mload(revertReason))
                }
            }
        }

        // The bootloader never returns any data, so it can safely be ignored here.
        (bool success, ) = payable(BOOTLOADER_FORMAL_ADDRESS).call{
            value: requiredETH
        }("");
        require(
            success,
            "Failed to transfer tx fee to the bootloader. Paymaster balance might not be enough."
        );
    } else {
        revert("Unsupported paymaster flow");
    }
    
}

Have you tried to isolate the problem, and if so, what were the results?

No i couldn't resolve it.

What steps have you already taken to try to resolve the issue?

Comment the lines in the paymaster which basically check whether the paymaster validateandpayfortransaction function is called a registred module or account !!

Repo Link (Optional)

No response

Additional Details

There are 2 external contracts Module manager and Accountregistry contracts features added to the basic AA repo. As the error seems like a function selector error which means the module registry function couldn't be called ?? or sometimes i do get a cannot estimate gas error when the paymaster contract is called from a script !!

[uF4No]

Try manually passing the gas params in the transaction overrides when sending the transaction:

await (
await erc20.mint(emptyWallet.address, 5, {
  // specify gas values
  maxFeePerGas: gasPrice,
  maxPriorityFeePerGas: 0,
  gasLimit: gasLimit,
  // paymaster info
  customData: {
    paymasterParams: paymasterParams,
    gasPerPubdata: utils.DEFAULT_GAS_PER_PUBDATA_LIMIT,
  },
})
).wait();

[4NNNN]

Okay but now the function is being called from the eoa wallet pk rather than the account address, i believe the account address cannot initiate a transaction so, the account registry registers account addresses when the factory deploys a new account address. Thus if i'm calling the paymaster from a script i'll have to use the eoa pk to initiate a transaction but the account registry doesn't have the eoa address registered to it !! How do i call a mint function through paymaster from a account address

[4NNNN]

Anyways, for testing purposes i added the initiator wallet address just to see if the transaction go through, but still the issue isn't solved. I parsed in the max gas fee still couldn't overcome the paymaster validation error !!

ERC20 token balance of the empty wallet before mint: 0
Paymaster ETH balance is 60000000000000000
BigNumber { _hex: '0x0ee6b280', _isBigNumber: true }
{
paymaster: '0x810F0b09C6eb750206aD44cA66C3c508680E2a5e',
paymasterInput: '0x949431dc0000000000000000000000000270c7061f7e934badea93b98a18558978224757000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000'
}
after this
Minting 5 tokens for empty wallet via paymaster...
An unexpected error occurred:

Error: processing response error (body="{"jsonrpc":"2.0","error":{"code":3,"message":"failed to validate the transaction. reason: Validation revert: Paymaster validation error: Error function_selector = 0x, data = 0x","data":"0x"},"id":54}\n", error={"code":3,"data":"0x"}, requestBody="{"method":"eth_sendRawTransaction","params":[""],"id":54,"jsonrpc":"2.0"}", requestMethod="POST", url="https://testnet.era.zksync.dev", code=SERVER_ERROR, version=web/5.7.1)

at processTicksAndRejections (node:internal/process/task_queues:95:5) {

reason: 'processing response error',
code: 'SERVER_ERROR',
body: '{"jsonrpc":"2.0","error":{"code":3,"message":"failed to validate the transaction. reason: Validation revert: Paymaster validation error: Error function_selector = 0x, data = 0x","data":"0x"},"id":54}\n',
error: Error: failed to validate the transaction. reason: Validation revert: Paymaster validation error: Error function_selector = 0x, data = 0x
at getResult (/Users/charan/Downloads/wallet/zksync-account-trade-limit/node_modules/@ethersproject/providers/src.ts/json-rpc-provider.ts:142:28)
at processJsonFunc (/Users/charan/Downloads/wallet/zksync-account-trade-limit/node_modules/@ethersproject/web/src.ts/index.ts:383:22)
at /Users/charan/Downloads/wallet/zksync-account-trade-limit/node_modules/@ethersproject/web/src.ts/index.ts:320:42
at step (/Users/charan/Downloads/wallet/zksync-account-trade-limit/node_modules/@ethersproject/web/lib/index.js:33:23)
at Object.next (/Users/charan/Downloads/wallet/zksync-account-trade-limit/node_modules/@ethersproject/web/lib/index.js:14:53)
at fulfilled (/Users/charan/Downloads/wallet/zksync-account-trade-limit/node_modules/@ethersproject/web/lib/index.js:5:58)
at processTicksAndRejections (node:internal/process/task_queues:95:5) {
code: 3,
data: '0x'
},
requestBody: '{"method":"eth_sendRawTransaction","params"://edited,"id":54,"jsonrpc":"2.0"}',
requestMethod: 'POST',
url: 'https://testnet.era.zksync.dev',
transaction: {
type: 113,
nonce: 1839,
maxPriorityFeePerGas: BigNumber { _hex: '0x00', _isBigNumber: true },
maxFeePerGas: BigNumber { _hex: '0x0ee6b280', _isBigNumber: true },
gasLimit: BigNumber { _hex: '0xd693a400', _isBigNumber: true },
to: '0x0270c7061f7E934badeA93b98A18558978224757',
value: BigNumber { _hex: '0x00', _isBigNumber: true },
data: '0x40c10f1900000000000000000000000036615cf349d7f6344891b1e7ca7c72883f5dc0490000000000000000000000000000000000000000000000000000000000000005',
chainId: BigNumber { _hex: '0x0118', _isBigNumber: true },
from: '0x36615Cf349d7F6344891B1e7CA7C72883F5dc049',
customData: {
gasPerPubdata: [BigNumber],
factoryDeps: [],
customSignature: '0x74440b448e3e3311c239fbb5e86b21e00cbdce0f8e971e64c711bb05c90f52326b2ffc4687037ae2c9fb9623c35305b2c4b59eb0365558ac06667b8497bf0fdf1c',
paymasterParams: [Object]
},
hash: '0xcd4ecc782d258e8ca9385f4714c07b7710cd7d83f77c227511011a48cd915fbe',
confirmations: 0
},
transactionHash: '0xcd4ecc782d258e8ca9385f4714c07b7710cd7d83f77c227511011a48cd915fbe'
}

[uF4No]

I don't know the logic you want to implement in your paymaster so I'm sharing a few things to consider:

• If your paymaster is not going to receive ERC20 tokens in exchange for the gas fees, you can use the General flow instead of ApprovalBased. The general flow does not require a token or minimalAllowance in the paymaster params.
• Given the error, most likely one of the validations in your paymaster is not passing. Try testing this contract locally with the local-setup for easier debugging.

How do i call a mint function through paymaster from a account address

You'd need to build a frontend for the smart contract account or just send the transaction from a script. AA unlocks many features (different signatures, native multisig, recovery...) but most current wallets are not prepared for them. You can see how to send a transaction from a smart contract account via script here. You'd just need to add the paymasterParams and the account correspondent customSignature inside customData.

[4NNNN]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {IPaymaster, ExecutionResult, PAYMASTER_VALIDATION_SUCCESS_MAGIC} from "@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IPaymaster.sol";
import {IPaymasterFlow} from "@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IPaymasterFlow.sol";
import {TransactionHelper, Transaction} from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";

import "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
import {IAccountRegistry} from "./interfaces/IAccountRegistry.sol";
import {IModuleManager} from "./interfaces/IModuleManager.sol";
import {IModule} from "./interfaces/IModule.sol";

contract MyPaymaster is IPaymaster {
using TransactionHelper for Transaction;
uint256 constant PRICE_FOR_PAYING_FEES = 1;
address public owner;
address public moduleManager;
address public allowedToken;

modifier onlyBootloader() {
    require(
        msg.sender == BOOTLOADER_FORMAL_ADDRESS,
        "Only bootloader can call this method"
    );
    // Continue execution if called from the bootloader.
    _;
}

 modifier onlyOwner() {
    require(msg.sender == owner, "NOT_OWNER");
    _;
}

/**
@param _moduleId the identifier number of a module.
@param moduleBaseAddr the address of the moduleBase contract
@param isValid true if module is authorized by owner
*/
struct Module {
    uint256 moduleId;
    address moduleBaseAddr;
    bool isValid;
}

mapping(address => Module) public modules; // module address => Module


constructor(address _erc20,address _moduleManager) {
    allowedToken = _erc20;
    moduleManager = _moduleManager;
}

/**
@notice this function addes modules that are verifed by ModuleManager.
@dev it stores moduleId, mdoule addresses in Module struct in modules mapping.
@param _moduleId the identifier number of a module.
 */
function addModule(uint256 _moduleId) public onlyOwner {
    require(_moduleId != 0, "INVALID_NUMBER");

    (address _moduleAddr, address _moduleBaseAddr) = IModuleManager(
        moduleManager
    ).getModule(_moduleId);

    Module storage module = modules[_moduleAddr];
    module.moduleId = _moduleId;
    module.moduleBaseAddr = _moduleBaseAddr;
    module.isValid = true;
}

/**
@notice this function removes that are already added by addModule().
@dev it turns isValid boolean value false in Module struct in modules mapping.
@param _moduleId the identifier number of a module.
 */
function removeModule(uint256 _moduleId) public onlyOwner {
    require(_moduleId != 0, "INVALID_NUMBER");

    (address _moduleAddr, ) = IModuleManager(moduleManager).getModule(
        _moduleId
    );

    Module storage module = modules[_moduleAddr];

    require(module.isValid, "NOT_ENABLED");
    module.isValid = false;
}

function validateAndPayForPaymasterTransaction(
    bytes32,
    bytes32,
    Transaction calldata _transaction
)
    external
    payable
    onlyBootloader
    returns (bytes4 magic, bytes memory context)
{
    magic = PAYMASTER_VALIDATION_SUCCESS_MAGIC;
    require(
        _transaction.paymasterInput.length >= 4,
        "The standard paymaster input must be at least 4 bytes long"
    );
    address from = address(uint160(_transaction.from));

    address registry = IModuleManager(moduleManager).accountRegistry();
    require(IAccountRegistry(registry).isAccount(from), "INVALID_ACCOUNT");
    // By default we consider the transaction as accepted.
    

    bytes4 paymasterInputSelector = bytes4(
        _transaction.paymasterInput[0:4]
    );
    if (paymasterInputSelector == IPaymasterFlow.approvalBased.selector) {
        // While the transaction data consists of address, uint256 and bytes data,
        // the data is not needed for this paymaster
        (address token, uint256 amount, bytes memory data) = abi.decode(
            _transaction.paymasterInput[4:],
            (address, uint256, bytes)
        );

        // Verify if token is the correct one
        require(token == allowedToken, "Invalid token");

        // We verify that the user has provided enough allowance
        address userAddress = address(uint160(_transaction.from));

        address thisAddress = address(this);

        uint256 providedAllowance = IERC20(token).allowance(
            userAddress,
            thisAddress
        );
        require(
            providedAllowance >= PRICE_FOR_PAYING_FEES,
            "Min allowance too low"
        );

        // Note, that while the minimal amount of ETH needed is tx.gasPrice * tx.gasLimit,
        // neither paymaster nor account are allowed to access this context variable.
        uint256 requiredETH = _transaction.gasLimit *
            _transaction.maxFeePerGas;

        try
            IERC20(token).transferFrom(userAddress, thisAddress, amount)
        {} catch (bytes memory revertReason) {
            // If the revert reason is empty or represented by just a function selector,
            // we replace the error with a more user-friendly message
            if (revertReason.length <= 4) {
                revert("Failed to transferFrom from users' account");
            } else {
                assembly {
                    revert(add(0x20, revertReason), mload(revertReason))
                }
            }
        }

        // The bootloader never returns any data, so it can safely be ignored here.
        (bool success, ) = payable(BOOTLOADER_FORMAL_ADDRESS).call{
            value: requiredETH
        }("");
        require(
            success,
            "Failed to transfer tx fee to the bootloader. Paymaster balance might not be enough."
        );
    } else {
        revert("Unsupported paymaster flow");
    }
    
}

function postTransaction(
    bytes calldata _context,
    Transaction calldata _transaction,
    bytes32,
    bytes32,
    ExecutionResult _txResult,
    uint256 _maxRefundedGas
) external payable override onlyBootloader {
    // Refunds are not supported yet.
}

receive() external payable {}

}

[4NNNN]

I have been trying to implement support for adding and removing modules for smart accounts. The paymaster has 2 functions add module and remove. The extra contratcs that i have included in my code is Accountregistry and module manager ( account registry - just maps all the accounts created from the factory and module manager helps with add and removing modules. Inside the validateandpayfortransaction function :

address from = address(uint160(_transaction.from));
address registry = IModuleManager(moduleManager).accountRegistry();
require(IAccountRegistry(registry).isAccount(from), "INVALID_ACCOUNT");

There is a require statement which checks that the function caller's address is aldready available in the accountregistry or not
thats all i have implemented. I tried the general paymaster methos and still the same paymaster validation error it is

[dutterbutter]

@4NNNN is this is still an issue or can we close this out?

[4NNNN]

The paymaster validation error is solved. But I have another doubt about deploying contracts directly using the contract deployer, the only reason why I'm using the contractdeployer contract directly instead of using the hardhat plugin is that I can't use the hardhat plugin without the hardhatruntime env. For example if I want to deploy new accounts and a set of modules for those parallely from the frontend, I believe calling contract deployer is the only go !

But I tried to hash the bytecode with the zksync specified format check the script, I'm getting a "message":"execution reverted: The code hash is not known" error

function generateBytecodeHash(bytecode) {
// Calculate the sha256 hash of the bytecode
const sha256Hash = crypto.createHash('sha256').update(bytecode).digest();

// Get the last 28 bytes of the sha256 hash
const last28Bytes = sha256Hash.slice(-28);

// Get the length of the bytecode in 32-byte words
const bytecodeLength = Math.ceil(bytecode.length / 32);

// Create a buffer for the bytecode hash
const bytecodeHash = Buffer.alloc(32);

// Set the first 2 bytes to the version of the bytecode hash format
bytecodeHash[0] = 1;
bytecodeHash[1] = 0;

// Set the second 2 bytes to the length of the bytecode
bytecodeHash.writeUInt16BE(bytecodeLength, 2);

// Set the rest of the bytes to the last 28 bytes of the sha256 hash
last28Bytes.copy(bytecodeHash, 4);

return bytecodeHash;

}
console.log(generateBytecodeHash(guard).toString('hex'));

[MexicanAce]

Going to mark this discussion as resolved, as the other issue regarding The code hash is not known is being discussed in a separate Discussion: #125

[cryptoman04]

@4NNNN how did you solve the validation error? im literally getting the same error and I followed the example step by step.

[mubraj]

it worked this time, for me

[4NNNN]

This issue was solved a long time ago, I think it was just a gas estimation error which I was facing and couple of others which I managed to fix!

[therntibmaph]

It seems like there might be an issue with the encoding or decoding of parameters when calling the validateAndPayForPaymasterTransaction function in the Paymaster contract. Specifically, ensure that the parameters passed to the function, such as paymasterInput, are correctly formatted and decoded within the function. Additionally, double-check that the relevant addresses, such as the Paymaster address and token address, are correct and accessible. If you're encountering gas estimation errors, consider adjusting the gas limit parameters or verifying that the contract's state allows for the transaction to be executed successfully within the given gas limits. Finally, for the function selector error, ensure that the correct function signature is being used when calling the Paymaster contract.

[4NNNN]

This issue was solved months ago, now check out @dutterbutter repo was paymaster examples!