dequanto 0.0.1 → 0.1.3

package/test/fixtures/erc4337/interfaces/IStakeManager.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.12;
+
+/**
+ * manage deposits and stakes.
+ * deposit is just a balance used to pay for UserOperations (either by a paymaster or an account)
+ * stake is value locked for at least "unstakeDelay" by the staked entity.
+ */
+interface IStakeManager {
+
+    event Deposited(
+        address indexed account,
+        uint256 totalDeposit
+    );
+
+    event Withdrawn(
+        address indexed account,
+        address withdrawAddress,
+        uint256 amount
+    );
+
+    /// Emitted when stake or unstake delay are modified
+    event StakeLocked(
+        address indexed account,
+        uint256 totalStaked,
+        uint256 unstakeDelaySec
+    );
+
+    /// Emitted once a stake is scheduled for withdrawal
+    event StakeUnlocked(
+        address indexed account,
+        uint256 withdrawTime
+    );
+
+    event StakeWithdrawn(
+        address indexed account,
+        address withdrawAddress,
+        uint256 amount
+    );
+
+    /**
+     * @param deposit the entity's deposit
+     * @param staked true if this entity is staked.
+     * @param stake actual amount of ether staked for this entity.
+     * @param unstakeDelaySec minimum delay to withdraw the stake.
+     * @param withdrawTime - first block timestamp where 'withdrawStake' will be callable, or zero if already locked
+     * @dev sizes were chosen so that (deposit,staked, stake) fit into one cell (used during handleOps)
+     *    and the rest fit into a 2nd cell.
+     *    112 bit allows for 10^15 eth
+     *    48 bit for full timestamp
+     *    32 bit allows 150 years for unstake delay
+     */
+    struct DepositInfo {
+        uint112 deposit;
+        bool staked;
+        uint112 stake;
+        uint32 unstakeDelaySec;
+        uint48 withdrawTime;
+    }
+
+    //API struct used by getStakeInfo and simulateValidation
+    struct StakeInfo {
+        uint256 stake;
+        uint256 unstakeDelaySec;
+    }
+
+    /// @return info - full deposit information of given account
+    function getDepositInfo(address account) external view returns (DepositInfo memory info);
+
+    /// @return the deposit (for gas payment) of the account
+    function balanceOf(address account) external view returns (uint256);
+
+    /**
+     * add to the deposit of the given account
+     */
+    function depositTo(address account) external payable;
+
+    /**
+     * add to the account's stake - amount and delay
+     * any pending unstake is first cancelled.
+     * @param _unstakeDelaySec the new lock duration before the deposit can be withdrawn.
+     */
+    function addStake(uint32 _unstakeDelaySec) external payable;
+
+    /**
+     * attempt to unlock the stake.
+     * the value can be withdrawn (using withdrawStake) after the unstake delay.
+     */
+    function unlockStake() external;
+
+    /**
+     * withdraw from the (unlocked) stake.
+     * must first call unlockStake and wait for the unstakeDelay to pass
+     * @param withdrawAddress the address to send withdrawn value.
+     */
+    function withdrawStake(address payable withdrawAddress) external;
+
+    /**
+     * withdraw from the deposit.
+     * @param withdrawAddress the address to send withdrawn value.
+     * @param withdrawAmount the amount to withdraw.
+     */
+    function withdrawTo(address payable withdrawAddress, uint256 withdrawAmount) external;
+}

package/test/fixtures/erc4337/interfaces/UserOperation.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+/* solhint-disable no-inline-assembly */
+
+import {calldataKeccak} from "../core/Helpers.sol";
+
+/**
+ * User Operation struct
+ * @param sender the sender account of this request.
+     * @param nonce unique value the sender uses to verify it is not a replay.
+     * @param initCode if set, the account contract will be created by this constructor/
+     * @param callData the method call to execute on this account.
+     * @param callGasLimit the gas limit passed to the callData method call.
+     * @param verificationGasLimit gas used for validateUserOp and validatePaymasterUserOp.
+     * @param preVerificationGas gas not calculated by the handleOps method, but added to the gas paid. Covers batch overhead.
+     * @param maxFeePerGas same as EIP-1559 gas parameter.
+     * @param maxPriorityFeePerGas same as EIP-1559 gas parameter.
+     * @param paymasterAndData if set, this field holds the paymaster address and paymaster-specific data. the paymaster will pay for the transaction instead of the sender.
+     * @param signature sender-verified signature over the entire request, the EntryPoint address and the chain ID.
+     */
+    struct UserOperation {
+
+        address sender;
+        uint256 nonce;
+        bytes initCode;
+        bytes callData;
+        uint256 callGasLimit;
+        uint256 verificationGasLimit;
+        uint256 preVerificationGas;
+        uint256 maxFeePerGas;
+        uint256 maxPriorityFeePerGas;
+        bytes paymasterAndData;
+        bytes signature;
+    }
+
+/**
+ * Utility functions helpful when working with UserOperation structs.
+ */
+library UserOperationLib {
+
+    function getSender(UserOperation calldata userOp) internal pure returns (address) {
+        address data;
+        //read sender from userOp, which is first userOp member (saves 800 gas...)
+        assembly {data := calldataload(userOp)}
+        return address(uint160(data));
+    }
+
+    //relayer/block builder might submit the TX with higher priorityFee, but the user should not
+    // pay above what he signed for.
+    function gasPrice(UserOperation calldata userOp) internal view returns (uint256) {
+    unchecked {
+        uint256 maxFeePerGas = userOp.maxFeePerGas;
+        uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
+        if (maxFeePerGas == maxPriorityFeePerGas) {
+            //legacy mode (for networks that don't support basefee opcode)
+            return maxFeePerGas;
+        }
+        return min(maxFeePerGas, maxPriorityFeePerGas + block.basefee);
+    }
+    }
+
+    function pack(UserOperation calldata userOp) internal pure returns (bytes memory ret) {
+        address sender = getSender(userOp);
+        uint256 nonce = userOp.nonce;
+        bytes32 hashInitCode = calldataKeccak(userOp.initCode);
+        bytes32 hashCallData = calldataKeccak(userOp.callData);
+        uint256 callGasLimit = userOp.callGasLimit;
+        uint256 verificationGasLimit = userOp.verificationGasLimit;
+        uint256 preVerificationGas = userOp.preVerificationGas;
+        uint256 maxFeePerGas = userOp.maxFeePerGas;
+        uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
+        bytes32 hashPaymasterAndData = calldataKeccak(userOp.paymasterAndData);
+
+        return abi.encode(
+            sender, nonce,
+            hashInitCode, hashCallData,
+            callGasLimit, verificationGasLimit, preVerificationGas,
+            maxFeePerGas, maxPriorityFeePerGas,
+            hashPaymasterAndData
+        );
+    }
+
+    function hash(UserOperation calldata userOp) internal pure returns (bytes32) {
+        return keccak256(pack(userOp));
+    }
+
+    function min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
+}

package/test/fixtures/erc4337/samples/DepositPaymaster.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+/* solhint-disable reason-string */
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import "../core/BasePaymaster.sol";
+import "./IOracle.sol";
+
+/**
+ * A token-based paymaster that accepts token deposits
+ * The deposit is only a safeguard: the user pays with his token balance.
+ *  only if the user didn't approve() the paymaster, or if the token balance is not enough, the deposit will be used.
+ *  thus the required deposit is to cover just one method call.
+ * The deposit is locked for the current block: the user must issue unlockTokenDeposit() to be allowed to withdraw
+ *  (but can't use the deposit for this or further operations)
+ *
+ * paymasterAndData holds the paymaster address followed by the token address to use.
+ * @notice This paymaster will be rejected by the standard rules of EIP4337, as it uses an external oracle.
+ * (the standard rules ban accessing data of an external contract)
+ * It can only be used if it is "whitelisted" by the bundler.
+ * (technically, it can be used by an "oracle" which returns a static value, without accessing any storage)
+ */
+contract DepositPaymaster is BasePaymaster {
+
+    using UserOperationLib for UserOperation;
+    using SafeERC20 for IERC20;
+
+    //calculated cost of the postOp
+    uint256 constant public COST_OF_POST = 35000;
+
+    IOracle private constant NULL_ORACLE = IOracle(address(0));
+    mapping(IERC20 => IOracle) public oracles;
+    mapping(IERC20 => mapping(address => uint256)) public balances;
+    mapping(address => uint256) public unlockBlock;
+
+    constructor(IEntryPoint _entryPoint) BasePaymaster(_entryPoint) {
+        //owner account is unblocked, to allow withdraw of paid tokens;
+        unlockTokenDeposit();
+    }
+
+    /**
+     * owner of the paymaster should add supported tokens
+     */
+    function addToken(IERC20 token, IOracle tokenPriceOracle) external onlyOwner {
+        require(oracles[token] == NULL_ORACLE, "Token already set");
+        oracles[token] = tokenPriceOracle;
+    }
+
+    /**
+     * deposit tokens that a specific account can use to pay for gas.
+     * The sender must first approve this paymaster to withdraw these tokens (they are only withdrawn in this method).
+     * Note depositing the tokens is equivalent to transferring them to the "account" - only the account can later
+     *  use them - either as gas, or using withdrawTo()
+     *
+     * @param token the token to deposit.
+     * @param account the account to deposit for.
+     * @param amount the amount of token to deposit.
+     */
+    function addDepositFor(IERC20 token, address account, uint256 amount) external {
+        //(sender must have approval for the paymaster)
+        token.safeTransferFrom(msg.sender, address(this), amount);
+        require(oracles[token] != NULL_ORACLE, "unsupported token");
+        balances[token][account] += amount;
+        if (msg.sender == account) {
+            lockTokenDeposit();
+        }
+    }
+
+    /**
+     * @return amount - the amount of given token deposited to the Paymaster.
+     * @return _unlockBlock - the block height at which the deposit can be withdrawn.
+     */
+    function depositInfo(IERC20 token, address account) public view returns (uint256 amount, uint256 _unlockBlock) {
+        amount = balances[token][account];
+        _unlockBlock = unlockBlock[account];
+    }
+
+    /**
+     * unlock deposit, so that it can be withdrawn.
+     * can't be called in the same block as withdrawTo()
+     */
+    function unlockTokenDeposit() public {
+        unlockBlock[msg.sender] = block.number;
+    }
+
+    /**
+     * lock the tokens deposited for this account so they can be used to pay for gas.
+     * after calling unlockTokenDeposit(), the account can't use this paymaster until the deposit is locked.
+     */
+    function lockTokenDeposit() public {
+        unlockBlock[msg.sender] = 0;
+    }
+
+    /**
+     * withdraw tokens.
+     * can only be called after unlock() is called in a previous block.
+     * @param token the token deposit to withdraw
+     * @param target address to send to
+     * @param amount amount to withdraw
+     */
+    function withdrawTokensTo(IERC20 token, address target, uint256 amount) public {
+        require(unlockBlock[msg.sender] != 0 && block.number > unlockBlock[msg.sender], "DepositPaymaster: must unlockTokenDeposit");
+        balances[token][msg.sender] -= amount;
+        token.safeTransfer(target, amount);
+    }
+
+    /**
+     * translate the given eth value to token amount
+     * @param token the token to use
+     * @param ethBought the required eth value we want to "buy"
+     * @return requiredTokens the amount of tokens required to get this amount of eth
+     */
+    function getTokenValueOfEth(IERC20 token, uint256 ethBought) internal view virtual returns (uint256 requiredTokens) {
+        IOracle oracle = oracles[token];
+        require(oracle != NULL_ORACLE, "DepositPaymaster: unsupported token");
+        return oracle.getTokenValueOfEth(ethBought);
+    }
+
+    /**
+     * Validate the request:
+     * The sender should have enough deposit to pay the max possible cost.
+     * Note that the sender's balance is not checked. If it fails to pay from its balance,
+     * this deposit will be used to compensate the paymaster for the transaction.
+     */
+    function _validatePaymasterUserOp(UserOperation calldata userOp, bytes32 userOpHash, uint256 maxCost)
+    internal view override returns (bytes memory context, uint256 validationData) {
+
+        (userOpHash);
+        // verificationGasLimit is dual-purposed, as gas limit for postOp. make sure it is high enough
+        require(userOp.verificationGasLimit > COST_OF_POST, "DepositPaymaster: gas too low for postOp");
+
+        bytes calldata paymasterAndData = userOp.paymasterAndData;
+        require(paymasterAndData.length == 20+20, "DepositPaymaster: paymasterAndData must specify token");
+        IERC20 token = IERC20(address(bytes20(paymasterAndData[20:])));
+        address account = userOp.getSender();
+        uint256 maxTokenCost = getTokenValueOfEth(token, maxCost);
+        uint256 gasPriceUserOp = userOp.gasPrice();
+        require(unlockBlock[account] == 0, "DepositPaymaster: deposit not locked");
+        require(balances[token][account] >= maxTokenCost, "DepositPaymaster: deposit too low");
+        return (abi.encode(account, token, gasPriceUserOp, maxTokenCost, maxCost),0);
+    }
+
+    /**
+     * perform the post-operation to charge the sender for the gas.
+     * in normal mode, use transferFrom to withdraw enough tokens from the sender's balance.
+     * in case the transferFrom fails, the _postOp reverts and the entryPoint will call it again,
+     * this time in *postOpReverted* mode.
+     * In this mode, we use the deposit to pay (which we validated to be large enough)
+     */
+    function _postOp(PostOpMode mode, bytes calldata context, uint256 actualGasCost) internal override {
+
+        (address account, IERC20 token, uint256 gasPricePostOp, uint256 maxTokenCost, uint256 maxCost) = abi.decode(context, (address, IERC20, uint256, uint256, uint256));
+        //use same conversion rate as used for validation.
+        uint256 actualTokenCost = (actualGasCost + COST_OF_POST * gasPricePostOp) * maxTokenCost / maxCost;
+        if (mode != PostOpMode.postOpReverted) {
+            // attempt to pay with tokens:
+            token.safeTransferFrom(account, address(this), actualTokenCost);
+        } else {
+            //in case above transferFrom failed, pay with deposit:
+            balances[token][account] -= actualTokenCost;
+        }
+        balances[token][owner()] += actualTokenCost;
+    }
+}

package/test/fixtures/erc4337/samples/IOracle.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+interface IOracle {
+
+    /**
+     * return amount of tokens that are required to receive that much eth.
+     */
+    function getTokenValueOfEth(uint256 ethOutput) external view returns (uint256 tokenInput);
+}
+

package/test/fixtures/erc4337/samples/SimpleAccount.sol

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+/* solhint-disable avoid-low-level-calls */
+/* solhint-disable no-inline-assembly */
+/* solhint-disable reason-string */
+
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+import "../core/BaseAccount.sol";
+import "./callback/TokenCallbackHandler.sol";
+
+/**
+  * minimal account.
+  *  this is sample minimal account.
+  *  has execute, eth handling methods
+  *  has a single signer that can send requests through the entryPoint.
+  */
+contract SimpleAccount is BaseAccount, TokenCallbackHandler, UUPSUpgradeable, Initializable {
+    using ECDSA for bytes32;
+
+    address public owner;
+
+    IEntryPoint private immutable _entryPoint;
+
+    event SimpleAccountInitialized(IEntryPoint indexed entryPoint, address indexed owner);
+
+    modifier onlyOwner() {
+        _onlyOwner();
+        _;
+    }
+
+    /// @inheritdoc BaseAccount
+    function entryPoint() public view virtual override returns (IEntryPoint) {
+        return _entryPoint;
+    }
+
+
+    // solhint-disable-next-line no-empty-blocks
+    receive() external payable {}
+
+    constructor(IEntryPoint anEntryPoint) {
+        _entryPoint = anEntryPoint;
+        _disableInitializers();
+    }
+
+    function _onlyOwner() internal view {
+        //directly from EOA owner, or through the account itself (which gets redirected through execute())
+        require(msg.sender == owner || msg.sender == address(this), "only owner");
+    }
+
+    /**
+     * execute a transaction (called directly from owner, or by entryPoint)
+     */
+    function execute(address dest, uint256 value, bytes calldata func) external {
+        _requireFromEntryPointOrOwner();
+        _call(dest, value, func);
+    }
+
+    /**
+     * execute a sequence of transactions
+     */
+    function executeBatch(address[] calldata dest, bytes[] calldata func) external {
+        _requireFromEntryPointOrOwner();
+        require(dest.length == func.length, "wrong array lengths");
+        for (uint256 i = 0; i < dest.length; i++) {
+            _call(dest[i], 0, func[i]);
+        }
+    }
+
+    /**
+     * @dev The _entryPoint member is immutable, to reduce gas consumption.  To upgrade EntryPoint,
+     * a new implementation of SimpleAccount must be deployed with the new EntryPoint address, then upgrading
+      * the implementation by calling `upgradeTo()`
+     */
+    function initialize(address anOwner) public virtual initializer {
+        _initialize(anOwner);
+    }
+
+    function _initialize(address anOwner) internal virtual {
+        owner = anOwner;
+        emit SimpleAccountInitialized(_entryPoint, owner);
+    }
+
+    // Require the function call went through EntryPoint or owner
+    function _requireFromEntryPointOrOwner() internal view {
+        require(msg.sender == address(entryPoint()) || msg.sender == owner, "account: not Owner or EntryPoint");
+    }
+
+    /// implement template method of BaseAccount
+    function _validateSignature(UserOperation calldata userOp, bytes32 userOpHash)
+    internal override virtual returns (uint256 validationData) {
+        bytes32 hash = userOpHash.toEthSignedMessageHash();
+        if (owner != hash.recover(userOp.signature))
+            return SIG_VALIDATION_FAILED;
+        return 0;
+    }
+
+    function _call(address target, uint256 value, bytes memory data) internal {
+        (bool success, bytes memory result) = target.call{value : value}(data);
+        if (!success) {
+            assembly {
+                revert(add(result, 32), mload(result))
+            }
+        }
+    }
+
+    /**
+     * check current account deposit in the entryPoint
+     */
+    function getDeposit() public view returns (uint256) {
+        return entryPoint().balanceOf(address(this));
+    }
+
+    /**
+     * deposit more funds for this account in the entryPoint
+     */
+    function addDeposit() public payable {
+        entryPoint().depositTo{value : msg.value}(address(this));
+    }
+
+    /**
+     * withdraw value from the account's deposit
+     * @param withdrawAddress target to send to
+     * @param amount to withdraw
+     */
+    function withdrawDepositTo(address payable withdrawAddress, uint256 amount) public onlyOwner {
+        entryPoint().withdrawTo(withdrawAddress, amount);
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal view override {
+        (newImplementation);
+        _onlyOwner();
+    }
+}
+

package/test/fixtures/erc4337/samples/SimpleAccountFactory.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+import "@openzeppelin/contracts/utils/Create2.sol";
+import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+import "./SimpleAccount.sol";
+
+/**
+ * A sample factory contract for SimpleAccount
+ * A UserOperations "initCode" holds the address of the factory, and a method call (to createAccount, in this sample factory).
+ * The factory's createAccount returns the target account address even if it is already installed.
+ * This way, the entryPoint.getSenderAddress() can be called either before or after the account is created.
+ */
+contract SimpleAccountFactory {
+    SimpleAccount public immutable accountImplementation;
+
+    constructor(IEntryPoint _entryPoint) {
+        accountImplementation = new SimpleAccount(_entryPoint);
+    }
+
+    /**
+     * create an account, and return its address.
+     * returns the address even if the account is already deployed.
+     * Note that during UserOperation execution, this method is called only if the account is not deployed.
+     * This method returns an existing account address so that entryPoint.getSenderAddress() would work even after account creation
+     */
+    function createAccount(address owner,uint256 salt) public returns (SimpleAccount ret) {
+        address addr = getAddress(owner, salt);
+        uint codeSize = addr.code.length;
+        if (codeSize > 0) {
+            return SimpleAccount(payable(addr));
+        }
+        ret = SimpleAccount(payable(new ERC1967Proxy{salt : bytes32(salt)}(
+                address(accountImplementation),
+                abi.encodeCall(SimpleAccount.initialize, (owner))
+            )));
+    }
+
+    /**
+     * calculate the counterfactual address of this account as it would be returned by createAccount()
+     */
+    function getAddress(address owner,uint256 salt) public view returns (address) {
+        return Create2.computeAddress(bytes32(salt), keccak256(abi.encodePacked(
+                type(ERC1967Proxy).creationCode,
+                abi.encode(
+                    address(accountImplementation),
+                    abi.encodeCall(SimpleAccount.initialize, (owner))
+                )
+            )));
+    }
+}

package/test/fixtures/erc4337/samples/TokenPaymaster.sol

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+/* solhint-disable reason-string */
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../core/BasePaymaster.sol";
+
+/**
+ * A sample paymaster that defines itself as a token to pay for gas.
+ * The paymaster IS the token to use, since a paymaster cannot use an external contract.
+ * Also, the exchange rate has to be fixed, since it can't reference an external Uniswap or other exchange contract.
+ * subclass should override "getTokenValueOfEth" to provide actual token exchange rate, settable by the owner.
+ * Known Limitation: this paymaster is exploitable when put into a batch with multiple ops (of different accounts):
+ * - while a single op can't exploit the paymaster (if postOp fails to withdraw the tokens, the user's op is reverted,
+ *   and then we know we can withdraw the tokens), multiple ops with different senders (all using this paymaster)
+ *   in a batch can withdraw funds from 2nd and further ops, forcing the paymaster itself to pay (from its deposit)
+ * - Possible workarounds are either use a more complex paymaster scheme (e.g. the DepositPaymaster) or
+ *   to whitelist the account and the called method ids.
+ */
+contract TokenPaymaster is BasePaymaster, ERC20 {
+
+    //calculated cost of the postOp
+    uint256 constant public COST_OF_POST = 15000;
+
+    address public immutable theFactory;
+
+    constructor(address accountFactory, string memory _symbol, IEntryPoint _entryPoint) ERC20(_symbol, _symbol) BasePaymaster(_entryPoint) {
+        theFactory = accountFactory;
+        //make it non-empty
+        _mint(address(this), 1);
+
+        //owner is allowed to withdraw tokens from the paymaster's balance
+        _approve(address(this), msg.sender, type(uint).max);
+    }
+
+
+    /**
+     * helpers for owner, to mint and withdraw tokens.
+     * @param recipient - the address that will receive the minted tokens.
+     * @param amount - the amount it will receive.
+     */
+    function mintTokens(address recipient, uint256 amount) external onlyOwner {
+        _mint(recipient, amount);
+    }
+
+    /**
+     * transfer paymaster ownership.
+     * owner of this paymaster is allowed to withdraw funds (tokens transferred to this paymaster's balance)
+     * when changing owner, the old owner's withdrawal rights are revoked.
+     */
+    function transferOwnership(address newOwner) public override virtual onlyOwner {
+        // remove allowance of current owner
+        _approve(address(this), owner(), 0);
+        super.transferOwnership(newOwner);
+        // new owner is allowed to withdraw tokens from the paymaster's balance
+        _approve(address(this), newOwner, type(uint).max);
+    }
+
+    //Note: this method assumes a fixed ratio of token-to-eth. subclass should override to supply oracle
+    // or a setter.
+    function getTokenValueOfEth(uint256 valueEth) internal view virtual returns (uint256 valueToken) {
+        return valueEth / 100;
+    }
+
+    /**
+      * validate the request:
+      * if this is a constructor call, make sure it is a known account.
+      * verify the sender has enough tokens.
+      * (since the paymaster is also the token, there is no notion of "approval")
+      */
+    function _validatePaymasterUserOp(UserOperation calldata userOp, bytes32 /*userOpHash*/, uint256 requiredPreFund)
+    internal view override returns (bytes memory context, uint256 validationData) {
+        uint256 tokenPrefund = getTokenValueOfEth(requiredPreFund);
+
+        // verificationGasLimit is dual-purposed, as gas limit for postOp. make sure it is high enough
+        // make sure that verificationGasLimit is high enough to handle postOp
+        require(userOp.verificationGasLimit > COST_OF_POST, "TokenPaymaster: gas too low for postOp");
+
+        if (userOp.initCode.length != 0) {
+            _validateConstructor(userOp);
+            require(balanceOf(userOp.sender) >= tokenPrefund, "TokenPaymaster: no balance (pre-create)");
+        } else {
+
+            require(balanceOf(userOp.sender) >= tokenPrefund, "TokenPaymaster: no balance");
+        }
+
+        return (abi.encode(userOp.sender), 0);
+    }
+
+    // when constructing an account, validate constructor code and parameters
+    // we trust our factory (and that it doesn't have any other public methods)
+    function _validateConstructor(UserOperation calldata userOp) internal virtual view {
+        address factory = address(bytes20(userOp.initCode[0 : 20]));
+        require(factory == theFactory, "TokenPaymaster: wrong account factory");
+    }
+
+    /**
+     * actual charge of user.
+     * this method will be called just after the user's TX with mode==OpSucceeded|OpReverted (account pays in both cases)
+     * BUT: if the user changed its balance in a way that will cause  postOp to revert, then it gets called again, after reverting
+     * the user's TX , back to the state it was before the transaction started (before the validatePaymasterUserOp),
+     * and the transaction should succeed there.
+     */
+    function _postOp(PostOpMode mode, bytes calldata context, uint256 actualGasCost) internal override {
+        //we don't really care about the mode, we just pay the gas with the user's tokens.
+        (mode);
+        address sender = abi.decode(context, (address));
+        uint256 charge = getTokenValueOfEth(actualGasCost + COST_OF_POST);
+        //actualGasCost is known to be no larger than the above requiredPreFund, so the transfer should succeed.
+        _transfer(sender, address(this), charge);
+    }
+}