[Deployment] Custom signature validation AA deploy error

[4NNNN]

Environment

Testnet

zkSolc Version

latest

zksync-web3 Version

0.14.3

Hardhat.config.ts

import { HardhatUserConfig } from "hardhat/config";

import "@matterlabs/hardhat-zksync-node";
import "@matterlabs/hardhat-zksync-deploy";
import "@matterlabs/hardhat-zksync-solc";
import "@matterlabs/hardhat-zksync-verify";

const config: HardhatUserConfig = {
defaultNetwork: "inMemoryNode",
networks: {
zkSyncTestnet: {
url: "https://testnet.era.zksync.dev",
ethNetwork: "goerli",
zksync: true,
verifyURL: "https://zksync2-testnet-explorer.zksync.dev/contract_verification",
},
zkSyncMainnet: {
url: "https://mainnet.era.zksync.io",
ethNetwork: "mainnet",
zksync: true,
verifyURL: "https://zksync2-mainnet-explorer.zksync.io/contract_verification",
},
dockerizedNode: {
url: "http://localhost:3050",
ethNetwork: "http://localhost:8545",
zksync: true,
},
inMemoryNode: {
url: "http://127.0.0.1:8011",
ethNetwork: "", // in-memory node doesn't support eth node; removing this line will cause an error
zksync: true,
},
hardhat: {
zksync: true,
},
},
zksolc: {
version: "1.3.16",
settings: {
// find all available options in the official documentation
// https://era.zksync.io/docs/tools/hardhat/hardhat-zksync-solc.html#configuration
},
},
solidity: {
version: "0.8.17",
},
};

export default config;

Deployment Script (WITHOUT PRIVATE KEY)

import { utils, Wallet, Provider } from "zksync-web3";
import * as ethers from "ethers";
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
import dotenv from "dotenv";

dotenv.config();

export default async function (hre: HardhatRuntimeEnvironment) {
// @ts-ignore target zkSyncTestnet in config file which can be testnet or local
const provider = new Provider("http://127.0.0.1:8011");
const wallet = new Wallet("", provider);
const deployer = new Deployer(hre, wallet);
const factoryArtifact = await deployer.loadArtifact("AAFactory");
const aaArtifact = await deployer.loadArtifact("PasskeyAccount");

const GASLIMIT = {
gasLimit: ethers.utils.hexlify(1000000)}

const factory = await deployer.deploy(
factoryArtifact,
[utils.hashBytecode(aaArtifact.bytecode)],
undefined,
[aaArtifact.bytecode],
);

console.log(AA factory address: ${factory.address});

const aaFactory = new ethers.Contract(
factory.address,
factoryArtifact.abi,
wallet,
);

const salt = ethers.constants.HashZero;
const transaction = await(await aaFactory.deployAccount(salt,GASLIMIT)).wait();
const accountAddr = (await utils.getDeployedContracts(transaction))[0].deployedAddress
const accountContract = new ethers.Contract(accountAddr, aaArtifact.abi, wallet)
console.log(`account: "${accountContract.address}",`)

console.log("Funding smart contract account with some ETH");
await (
await wallet.sendTransaction({
to: accountContract.address,
value: ethers.utils.parseEther("0.005"),
})
).wait();
console.log(Done!);
}

Contract Code

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

import "@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IAccount.sol";
import "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";
// Access zkSync system contracts for nonce validation via NONCE_HOLDER_SYSTEM_CONTRACT
import "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
// to call non-view function of system contracts
import "@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractsCaller.sol";
import {IR1Validator, IERC165} from './interfaces/IValidator.sol';
import "./PasskeyManager.sol";
import "hardhat/console.sol";

contract Account is IAccount, PasskeyManager, IR1Validator {
// to get transaction hash
using TransactionHelper for Transaction;
address constant P256_VERIFIER = 0x18c994fD76764aE2229b85978361D23bCFc2aE5a;

// bytes4 constant EIP1271_SUCCESS_RETURN_VALUE = 0x1626ba7e;

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

function validateTransaction(
    bytes32,
    bytes32 _suggestedSignedHash,
    Transaction calldata _transaction
) external payable override onlyBootloader returns (bytes4 magic) {
    return _validateTransaction(_suggestedSignedHash, _transaction);
}

function _validateTransaction(
    bytes32 _suggestedSignedHash,
    Transaction calldata _transaction
) internal returns (bytes4 magic) {
    // Incrementing the nonce of the account.
    // Note, that reserved[0] by convention is currently equal to the nonce passed in the transaction
    SystemContractsCaller.systemCallWithPropagatedRevert(
        uint32(gasleft()),
        address(NONCE_HOLDER_SYSTEM_CONTRACT),
        0,
        abi.encodeCall(
            INonceHolder.incrementMinNonceIfEquals,
            (_transaction.nonce)
        )
    );

    bytes32 txHash;
    // While the suggested signed hash is usually provided, it is generally
    // not recommended to rely on it to be present, since in the future
    // there may be tx types with no suggested signed hash.
    if (_suggestedSignedHash == bytes32(0)) {
        txHash = _transaction.encodeHash();
        console.logBytes32(txHash);
    } else {
        txHash = _suggestedSignedHash;
    }

    // The fact there is are enough balance for the account
    // should be checked explicitly to prevent user paying for fee for a
    // transaction that wouldn't be included on Ethereum.
    uint256 totalRequiredBalance = _transaction.totalRequiredBalance();
    require(
        totalRequiredBalance <= address(this).balance,
        "Not enough balance for fee + value"
    );

    if (
        _validateSignature(txHash, _transaction.signature) ==
        true
    ) {
        magic = ACCOUNT_VALIDATION_SUCCESS_MAGIC;
    } else {
        magic = bytes4(0);
    }
}

function validateSignature(
    bytes32 signedHash,
    bytes calldata signature
) external view returns (bool valid){
    bool success = _validateSignature(signedHash,signature);
    if (success) valid = true;
}

function executeTransaction(
    bytes32,
    bytes32,
    Transaction calldata _transaction
) external payable override onlyBootloader {
    _executeTransaction(_transaction);
}

function _executeTransaction(Transaction calldata _transaction) internal {
    address to = address(uint160(_transaction.to));
    uint128 value = Utils.safeCastToU128(_transaction.value);
    bytes memory data = _transaction.data;

    if (to == address(DEPLOYER_SYSTEM_CONTRACT)) {
        uint32 gas = Utils.safeCastToU32(gasleft());

        // Note, that the deployer contract can only be called
        // with a "systemCall" flag.
        SystemContractsCaller.systemCallWithPropagatedRevert(
            gas,
            to,
            value,
            data
        );
    } else {
        bool success;
        assembly {
            success := call(
                gas(),
                to,
                value,
                add(data, 0x20),
                mload(data),
                0,
                0
            )
        }
        require(success);
    }
}

function executeTransactionFromOutside(
    Transaction calldata _transaction
) external payable {
    _validateTransaction(bytes32(0), _transaction);
    _executeTransaction(_transaction);
}

function _validateSignature(
    bytes32 _hash,
    bytes memory _signature
) internal view returns (bool) {
    (bytes32 keyHash, bytes32 sigx, bytes32 sigy, bytes memory authenticatorData, string memory clientDataJSONPre, string memory clientDataJSONPost) = 
        abi.decode(_signature, (bytes32, bytes32, bytes32, bytes, string, string));

    string memory opHashBase64 = Base64.encode(bytes.concat(_hash));
    string memory clientDataJSON = string.concat(clientDataJSONPre, opHashBase64, clientDataJSONPost);
    bytes32 clientHash = sha256(bytes(clientDataJSON));
    bytes32 sigHash = sha256(bytes.concat(authenticatorData, clientHash));
    PassKeyId memory passKey = authorisedKeys[keyHash];
    require(passKey.pubKeyX != 0 && passKey.pubKeyY != 0, "Key not found");
    require(callVerifier(sigHash, [sigx, sigy] , [passKey.pubKeyX, passKey.pubKeyY]), "Invalid signature");
    return true;
}

function getEncodeHash(Transaction calldata _transaction) public returns (bytes32){ 
    bytes32 txh;
    txh = _transaction.encodeHash();
    console.logBytes32(txh);
    return txh; 
}

function callVerifier(
    bytes32 hash,
    bytes32[2] memory rs,
    uint256[2] memory pubKey
) internal view returns (bool) {
    /**
     * Prepare the input format
     * input[  0: 32] = signed data hash
     * input[ 32: 64] = signature r
     * input[ 64: 96] = signature s
     * input[ 96:128] = public key x
     * input[128:160] = public key y
     */
    bytes memory input = abi.encodePacked(hash, rs[0], rs[1], pubKey[0], pubKey[1]);

    (bool success, bytes memory data) = P256_VERIFIER.staticcall(input);
    require(success); // never reverts, always returns 0 or 1
    console.logBytes(data);

    uint256 returnValue;
    // Return true if the call was successful and the return value is 1
    if (success && data.length > 0) {
        assembly {
            returnValue := mload(add(data, 0x20))
        }
        if (returnValue == 1) return true;
    }
    // Otherwise return false for the unsucessful calls and invalid signatures
    return false;
}

function payForTransaction(
    bytes32,
    bytes32,
    Transaction calldata _transaction
) external payable override onlyBootloader {
    bool success = _transaction.payToTheBootloader();
    require(success, "Failed to pay the fee to the operator");
}

function prepareForPaymaster(
    bytes32, // _txHash
    bytes32, // _suggestedSignedHash
    Transaction calldata _transaction
) external payable override onlyBootloader {
    _transaction.processPaymasterInput();
}

function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
    return
        interfaceId == type(IR1Validator).interfaceId ||
        interfaceId == type(IERC165).interfaceId;
}

fallback() external {
    // fallback of default account shouldn't be called by bootloader under no circumstances
    assert(msg.sender != BOOTLOADER_FORMAL_ADDRESS);

    // If the contract is called directly, behave like an EOA
}

receive() external payable {
    // If the contract is called directly, behave like an EOA.
    // Note, that is okay if the bootloader sends funds with no calldata as it may be used for refunds/operator payments
}

}

Does this work on other EVMs? (If yes, please list at least 1 of them)

NA

Description of What Your Contract Does

Simple AA wallet with passkey implementation and p256 signature validation,
Errors (Tested both in the in-memory node as well as in the testnet) -->

• Deployment failed
• What is the reason behind sender is not an account error ?

Repo Link (Optional)

https://github.com/4NNNN/P256_Account/tree/p256verify_testnet_deployment

Additional Details

Repo Branch - p256verify_testnet_deployment
Please try out the repo, the verifier address - 0x18c994fD76764aE2229b85978361D23bCFc2aE5a is testnet deployed, please use make deploy-verifier-local cmd to deploy it locally

[Romsters]

@4NNNN you need to add isSystem: true to your hardhat config. Docs: https://era.zksync.io/docs/reference/concepts/account-abstraction.html#using-the-systemcontractscaller-library.
Check the example here at p.6.

[4NNNN]

Can you explain why ?

[4NNNN]

Even if I do that, there's a "error: Error: failed to validate the transaction. reason: Validation revert: Account validation error: Error function_selector = 0x, data = 0x"

[bxpana]

@4NNNN I know this has been a bit, but did you end up getting this figured out?