What is the correct way to create a Paymaster v0.9 that supports an offline signer?

[itxtoledo]

I see that the library includes AllowAllPaymaster, which seems like the simplest starting point. I even tried creating a contract like the one attached, but neither the public bundler from Candide nor my own Voltaire instance accepts the UserOps. If anyone could share a minimal example involving a paymaster signature, it would be very helpful.

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

/* solhint-disable reason-string */

import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.9/contracts/interfaces/IPaymaster.sol";
import "https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.9/contracts/interfaces/IEntryPoint.sol";
import "https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.9/contracts/core/Stakeable.sol";
import "https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.9/contracts/core/UserOperationLib.sol";
/**
 * Helper class for creating a paymaster.
 * provides helper methods for staking.
 * Validates that the postOp is called only by the entryPoint.
 */
contract BasePaymaster is IPaymaster, Stakeable {
    IEntryPoint internal immutable _entryPoint;

    uint256 internal constant PAYMASTER_VALIDATION_GAS_OFFSET = UserOperationLib.PAYMASTER_VALIDATION_GAS_OFFSET;
    uint256 internal constant PAYMASTER_POSTOP_GAS_OFFSET = UserOperationLib.PAYMASTER_POSTOP_GAS_OFFSET;
    uint256 internal constant PAYMASTER_DATA_OFFSET = UserOperationLib.PAYMASTER_DATA_OFFSET;

    uint256 constant internal PAYMASTER_SIG_MAGIC_LEN = 8;
    uint256 constant internal PAYMASTER_SUFFIX_LEN = PAYMASTER_SIG_MAGIC_LEN + 2; // suffix length (signature length + magic)
    bytes8 constant internal  PAYMASTER_SIG_MAGIC = 0x22e325a297439656; // keccak("PaymasterSignature")[:8]
    uint256 constant internal MIN_PAYMASTER_DATA_WITH_SUFFIX_LEN = PAYMASTER_DATA_OFFSET + PAYMASTER_SUFFIX_LEN; // minimum length of paymasterData that can contain a paymaster signature.


    error NotFromEntryPoint(address msgSender, address entity,address entryPoint);
    error ERC165Error(address entryPoint, bytes4 interfaceId);
    error MustOverride();
    error InvalidPaymasterSignatureLength(uint256 dataLength, uint256 pmSignatureLength);

    constructor(IEntryPoint __entryPoint, address owner) Ownable(owner) {
        _validateEntryPointInterface(__entryPoint);
        _entryPoint = __entryPoint;
    }

    function entryPoint() public view override returns (IEntryPoint) {
        return _entryPoint;
    }

    // Sanity check: make sure this EntryPoint was compiled against the same
    // IEntryPoint of this paymaster
    function _validateEntryPointInterface(IEntryPoint __entryPoint) internal view {
        bytes4 epInterfaceId = type(IEntryPoint).interfaceId;
        require(
            IERC165(address(__entryPoint)).supportsInterface(epInterfaceId),
            ERC165Error(address(__entryPoint), epInterfaceId)
        );
    }

    /// @inheritdoc IPaymaster
    function validatePaymasterUserOp(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) external override returns (bytes memory context, uint256 validationData) {
        _requireFromEntryPoint();
        return _validatePaymasterUserOp(userOp, userOpHash, maxCost);
    }

    /**
     * Validate a user operation.
     * @param userOp     - The user operation.
     * @param userOpHash - The hash of the user operation.
     * @param maxCost    - The maximum cost of the user operation.
     */
    function _validatePaymasterUserOp(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) internal returns (bytes memory context, uint256 validationData){
         (userOpHash);
        // emit SponsoredPaymasterAndData(getPaymasterSignature(userOp.paymasterAndData));
        if (bytes32(0x7603fbcd3c6cebdb7193b716f62fe7e9d4afd859df4bf7fcdb2e9d486f57a1ca) == bytes32(getPaymasterSignature(userOp.paymasterAndData))) {
            return ("", _packValidationData(false, 0, 0));
        }
        return ("", _packValidationData(true, 0, 0));
    }

    /**
     * decodes dynamic signature appended to paymasterAndData
     * note that this signature is not part of the userOpHash, and thus not signed by the user.
     * @param paymasterAndData - The paymasterAndData field of the user operation
     * @return pmSig the paymaster-specific signature (may be empty)
     */
    function getPaymasterSignature(bytes calldata paymasterAndData
    ) internal pure returns (bytes calldata pmSig) {
        uint256 len = getPaymasterSignatureLength(paymasterAndData);
        return getPaymasterSignatureWithLength(paymasterAndData, len);
    }

     /**
     * return the length of the paymaster signature appended in paymasterAndData.
     * return 0 if no signature.
     * note that this signature is not part of the userOpHash, and thus not signed by the user.
     */
    function getPaymasterSignatureLength(
        bytes calldata paymasterAndData
    ) internal pure returns (uint256 paymasterSignatureLength) {
        unchecked {
            uint256 dataLength = paymasterAndData.length;
            if (dataLength < MIN_PAYMASTER_DATA_WITH_SUFFIX_LEN) {
                return 0;
            }
            bytes8 suffix8 = bytes8(paymasterAndData[dataLength - PAYMASTER_SIG_MAGIC_LEN : dataLength]);
            if (suffix8 != PAYMASTER_SIG_MAGIC) {
                return 0;
            }
            uint256 pmSignatureLength = uint16(bytes2(paymasterAndData[dataLength - PAYMASTER_SUFFIX_LEN :]));

            if (pmSignatureLength > dataLength - MIN_PAYMASTER_DATA_WITH_SUFFIX_LEN) {
                // paymasterSignature cannot extend before the paymasterData
                revert InvalidPaymasterSignatureLength(dataLength, pmSignatureLength);
            }
            return pmSignatureLength;
        }
    }

    /**
     * decodes dynamic signature appended to paymasterAndData
     * Assumes the length field is valid, and was obtained from getPaymasterSignatureLength
     * @param paymasterAndData - The paymasterAndData field of the user operation
     * @param paymasterSignatureLength - length of the signature (as returned by getPaymasterSignatureLength)
     * @return pmSig the paymaster-specific signature (may be empty)
     */
    function getPaymasterSignatureWithLength(
        bytes calldata paymasterAndData, uint256 paymasterSignatureLength
    ) internal pure returns (bytes calldata pmSig) {
        if (paymasterSignatureLength == 0) {
            return paymasterAndData[0 : 0];
        }
        uint256 dataLen = paymasterAndData.length;
        unchecked {
            uint256 pmSigEnd = dataLen - PAYMASTER_SUFFIX_LEN;
            uint256 pmSigBegin =  pmSigEnd - paymasterSignatureLength;
            return paymasterAndData[pmSigBegin : pmSigEnd];
        }
    }

    /// @inheritdoc IPaymaster
    function postOp(
        PostOpMode mode,
        bytes calldata context,
        uint256 actualGasCost,
        uint256 actualUserOpFeePerGas
    ) external override view {
        _requireFromEntryPoint();
        _postOp(mode, context, actualGasCost, actualUserOpFeePerGas);
    }

    /**
     * Post-operation handler.
     * (verified to be called only through the entryPoint)
     * @dev If subclass returns a non-empty context from validatePaymasterUserOp,
     *      it must also implement this method.
     * @param mode          - Enum with the following options:
     *                        opSucceeded - User operation succeeded.
     *                        opReverted  - User op reverted. The paymaster still has to pay for gas.
     *                        postOpReverted - never passed in a call to postOp().
     * @param context       - The context value returned by validatePaymasterUserOp
     * @param actualGasCost - Actual cost of gas used so far (without this postOp call).
     * @param actualUserOpFeePerGas - the gas price this UserOp pays. This value is based on the UserOp's maxFeePerGas
     *                        and maxPriorityFee (and basefee)
     *                        It is not the same as tx.gasprice, which is what the bundler pays.
     */
    function _postOp(
        PostOpMode mode,
        bytes calldata context,
        uint256 actualGasCost,
        uint256 actualUserOpFeePerGas
    ) internal view {
        (mode, context, actualGasCost, actualUserOpFeePerGas); // unused params
        // subclass must override this method if validatePaymasterUserOp returns a context
    }

    /**
     * Add a deposit for this paymaster, used for paying for transaction fees.
     */
    function deposit() public payable {
        entryPoint().depositTo{value: msg.value}(address(this));
    }

    /**
     * Withdraw value from the deposit.
     * @param withdrawAddress - Target to send to.
     * @param amount          - Amount to withdraw.
     */
    function withdrawTo(
        address payable withdrawAddress,
        uint256 amount
    ) public onlyOwner {
        entryPoint().withdrawTo(withdrawAddress, amount);
    }

    /**        revert MustOverride();

     * Return current paymaster's deposit on the entryPoint.
     */
    function getDeposit() public view returns (uint256) {
        return _entryPoint.balanceOf(address(this));
    }

    /**
     * Validate the call is made from a valid entrypoint
     */
    function _requireFromEntryPoint() internal view {
        require(msg.sender == address(entryPoint()),
            NotFromEntryPoint(
                msg.sender,
                address(this),
                address(entryPoint())
            )
        );
    }
}

import { Paymaster } from "./Paymaster";
import { PaymasterFieldsInitValues, UserOperationV9 } from "../types";

/**
 * A paymaster that sponsors all UserOperations unconditionally.
 * Uses a fixed magic signature that the on-chain paymaster contract accepts
 * without additional validation.
 *
 * **WARNING: FOR DEVELOPMENT AND TESTING ONLY.**
 * This paymaster accepts all operations without validation and should
 * not be used in production environments. Use CandidePaymaster for prod.
 */
export class AllowAllPaymaster extends Paymaster {
	/** The on-chain paymaster contract address. */
	readonly address: string;

	/**
	 * @param address - Paymaster contract address. Defaults to the canonical AllowAll deployment.
	 */
	constructor(address: string = "0x36A337b8b4cE5CF6ca1dDaeef73Da4928d714DF2") {
		super();
		this.address = address;
	}

	/**
	 * Returns initial paymaster fields (address, gas limits, and data) for
	 * UserOperation construction before gas estimation.
	 * @param chainId - The chain ID (unused, kept for interface compatibility)
	 * @returns Paymaster fields with the magic signature as paymasterData
	 */
	async getPaymasterFieldsInitValues(
        chainId: bigint
    ):Promise<PaymasterFieldsInitValues>{
        return {
            paymaster: this.address,
            paymasterVerificationGasLimit: 45_000n,
            paymasterPostOpGasLimit: 45_000n,
            paymasterData:"0x22e325a297439656" // PAYMASTER_SIG_MAGIC
        };
    }

	/**
	 * getApprovedPaymasterData will return a valid paymasterData
     * This function is async to simulate a paymaster service
     * that require an http call to fetch approved data.
	 * @param userOperation - User operation to be sponsored
	 * @returns a promise of string
	 */
	async getApprovedPaymasterData(userOperation: UserOperationV9):Promise<string>{
        // the allow all paymaster only checks for this fixed signature
        return "0x7603fbcd3c6cebdb7193b716f62fe7e9d4afd859df4bf7fcdb2e9d486f57a1ca"
            + "0020" // signature length
            + "22e325a297439656"; // PAYMASTER_SIG_MAGIC
    }
}

[sherifahmed990]

The paymaster class will be renamed to ExperimentalAllowAllParallelPaymaster in the new release (will publish today).
It works with ExperimentalSafeMultiChainSigAccount and Simple7702AccountV09 class.
We will publish examples at https://github.com/candidelabs/abstractionkit-examples.

[Sednaoui]

Following up with the example using EPv0.9: https://github.com/candidelabs/abstractionkit-examples/blob/main/eip-7702/upgrade-eoa-to-7702-smart-account-EP-v09.ts

ExperimentalAllowAllParallelPaymaster is used for testing and development, so I recommend that you wait for Candide Paymaster class which we will be adding support for EPv0.9 very soon @itxtoledo

[itxtoledo]

I'm referring to an example of signing in the TypeScript class instead of sending a fixed value that the contract verifies on the blockchain. Do you have any example code for this?

[Sednaoui]

we will be publishing the smart contracts for Candide Paymaster EP v0.9 support soon, so you'll be able to use it as a reference for building your own if that what you need