AA-440 validate using handleOps

.gitmodules

@@ -1,7 +1,7 @@
 [submodule "submodules/account-abstraction"]
 	path = submodules/account-abstraction
 	url = https://github.com/eth-infinitism/account-abstraction.git
-	branch = releases/v0.7
+	branch = callValidateUserOp-catch-revert
 [submodule "submodules/rip7560"]
 	path = submodules/rip7560
 	url = https://github.com/eth-infinitism/rip7560_contracts.git

packages/bundler/src/runBundler.ts

@@ -167,6 +167,9 @@ export async function runBundler (argv: string[], overrideExit = true): Promise<
     entryPoint
   } = await connectContracts(wallet, !config.rip7560)
   // bundleSize=1 replicate current immediate bundling mode
+  if (entryPoint != null && entryPoint.address != null) {
+    config.entryPoint = entryPoint.address
+  }
   const execManagerConfig = {
     ...config
     // autoBundleMempoolSize: 0

packages/bundler/test/BundlerServer.test.ts

@@ -1,5 +1,4 @@
 import { JsonRpcProvider } from '@ethersproject/providers'
-import { ethers } from 'hardhat'
 import { expect } from 'chai'
 import { parseEther } from 'ethers/lib/utils'
 
@@ -29,9 +28,14 @@ describe('BundleServer', function () {
   let entryPoint: IEntryPoint
   let server: BundlerServer
   before(async () => {
-    const provider = ethers.provider
+    // const provider = ethers.provider
+    const provider = new JsonRpcProvider('http://localhost:8545')
     const signer = await createSigner()
-    entryPoint = await deployEntryPoint(provider)
+    try {
+      entryPoint = await deployEntryPoint(provider)
+    } catch (e) {
+      throw new Error('Failed to deploy entry point - no geth?\n' + e)
+    }
 
     const config: BundlerConfig = {
       chainId: 1337,

packages/sdk/src/BaseAccountAPI.ts

@@ -2,7 +2,7 @@ import { ethers, BigNumber, BigNumberish, BytesLike } from 'ethers'
 import { Provider } from '@ethersproject/providers'
 
 import { TransactionDetailsForUserOp } from './TransactionDetailsForUserOp'
-import { defaultAbiCoder } from 'ethers/lib/utils'
+import { defaultAbiCoder, hexConcat, hexDataSlice } from 'ethers/lib/utils'
 import { PaymasterAPI } from './PaymasterAPI'
 import { encodeUserOp, getUserOpHash, IEntryPoint, IEntryPoint__factory, UserOperation } from '@account-abstraction/utils'
 
@@ -120,12 +120,13 @@ export abstract class BaseAccountAPI {
     if (factory == null) {
       throw new Error(('no counter factual address if not factory'))
     }
-    // use entryPoint to query account address (factory can provide a helper method to do the same, but
-    // this method attempts to be generic
-    const retAddr = await this.provider.call({
-      to: factory, data: factoryData
+    const getSenderAddressData = this.entryPointView.interface.encodeFunctionData('getSenderAddress', [hexConcat([factory, factoryData ?? '0x'])])
+    const senderAddressResult = await this.provider.call({
+      to: this.entryPointAddress,
+      data: getSenderAddressData
     })
-    const [addr] = defaultAbiCoder.decode(['address'], retAddr)
+    // the result is "error SenderAddressResult(address)", so remove methodsig first.
+    const [addr] = defaultAbiCoder.decode(['address'], hexDataSlice(senderAddressResult, 4))
     return addr
   }
 
@@ -205,7 +206,12 @@ export abstract class BaseAccountAPI {
     if (factoryParams == null) {
       return 0
     }
-    return await this.provider.estimateGas({ to: factoryParams.factory, data: factoryParams.factoryData })
+    const senderCreator = await this.entryPointView.senderCreator()
+    return await this.provider.estimateGas({
+      from: senderCreator,
+      to: factoryParams.factory,
+      data: factoryParams.factoryData
+    })
   }
 
   /**

packages/sdk/src/SimpleAccountAPI.ts

@@ -8,6 +8,7 @@ import {
 import { arrayify } from 'ethers/lib/utils'
 import { Signer } from '@ethersproject/abstract-signer'
 import { BaseApiParams, BaseAccountAPI, FactoryParams } from './BaseAccountAPI'
+import { ecsign, toRpcSig } from 'ethereumjs-util'
 
 /**
  * constructor params, added no top of base params:
@@ -100,6 +101,8 @@ export class SimpleAccountAPI extends BaseAccountAPI {
   }
 
   async signUserOpHash (userOpHash: string): Promise<string> {
-    return await this.owner.signMessage(arrayify(userOpHash))
+    const privateKey = (this.owner as any).privateKey
+    const sig = ecsign(Buffer.from(arrayify(userOpHash)), Buffer.from(arrayify(privateKey)))
+    return toRpcSig(sig.v, sig.r, sig.s)
   }
 }

packages/utils/contracts/GetStakes.sol

@@ -0,0 +1,31 @@
+pragma solidity >=0.8;
+// SPDX-License-Identifier: GPL-3.0
+
+import "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
+
+    struct StakeInfo {
+        address addr;
+        uint256 stake;
+        uint256 unstakeDelaySec;
+    }
+
+    error StakesRet(StakeInfo[] stakes);
+
+// helper: get stake info of multiple entities.
+// This contract is never deployed: it is called using eth_call, and it reverts with the result...
+contract GetStakes {
+
+    constructor(IEntryPoint entryPoint, address[] memory addrs) {
+        StakeInfo[] memory stakes = getStakes(entryPoint, addrs);
+        revert StakesRet(stakes);
+    }
+
+    function getStakes(IEntryPoint entryPoint, address[] memory addrs) public view returns (StakeInfo[] memory) {
+        StakeInfo[] memory stakes = new StakeInfo[](addrs.length);
+        for (uint256 i = 0; i < addrs.length; i++) {
+            IStakeManager.DepositInfo memory info = entryPoint.getDepositInfo(addrs[i]);
+            stakes[i] = StakeInfo(addrs[i], info.stake, info.unstakeDelaySec);
+        }
+        return stakes;
+    }
+}

packages/utils/contracts/Imports.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0
-pragma solidity ^0.8.23;
+pragma solidity ^0.8;
 
 import "@account-abstraction/contracts/core/EntryPointSimulations.sol";
 import "@account-abstraction/contracts/interfaces/IStakeManager.sol";
 import "@account-abstraction/contracts/samples/SimpleAccountFactory.sol";
-import "@account-abstraction/contracts/samples/TokenPaymaster.sol";
+//import "@account-abstraction/contracts/samples/TokenPaymaster.sol";
 import "@account-abstraction/rip7560/contracts/predeploys/Rip7560StakeManager.sol";
 
 import {NonceManager as NonceManagerRIP7712} from "@account-abstraction/rip7560/contracts/predeploys/NonceManager.sol";

packages/utils/hardhat.config.ts

@@ -9,8 +9,9 @@ const config: HardhatUserConfig = {
     target: 'ethers-v5'
   },
   solidity: {
-    version: '0.8.23',
+    version: '0.8.28',
     settings: {
+      evmVersion: 'cancun',
       optimizer: { enabled: true }
     }
   }

packages/utils/package.json

@@ -24,7 +24,7 @@
     "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/keccak256": "^5.7.0",
     "@ethersproject/providers": "^5.7.0",
-    "@openzeppelin/contracts": "^5.0.1",
+    "@openzeppelin/contracts": "^5.2.0",
     "debug": "^4.3.4",
     "ethereumjs-util": "^7.1.5",
     "ethers": "^5.7.0",

packages/utils/src/ERC4337Utils.ts

@@ -9,7 +9,7 @@ import {
 } from 'ethers/lib/utils'
 import { abi as entryPointAbi } from '@account-abstraction/contracts/artifacts/IEntryPoint.json'
 
-import { BigNumber, BigNumberish, BytesLike, ethers } from 'ethers'
+import { BigNumber, BigNumberish, BytesLike, ethers, TypedDataDomain, TypedDataField } from 'ethers'
 import Debug from 'debug'
 import { PackedUserOperation } from './Utils'
 import { UserOperation } from './interfaces/UserOperation'
@@ -25,6 +25,13 @@ if (PackedUserOpType == null) {
 
 export const AddressZero = ethers.constants.AddressZero
 
+// Matched to domain name, version from EntryPoint.sol:
+const DOMAIN_NAME = 'ERC4337'
+const DOMAIN_VERSION = '1'
+
+// Matched to UserOperationLib.sol:
+const PACKED_USEROP_TYPEHASH = keccak256(Buffer.from('PackedUserOperation(address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData)'))
+
 // reverse "Deferrable" or "PromiseOrValue" fields
 export type NotPromise<T> = {
   [P in keyof T]: Exclude<T[P], Promise<any>>
@@ -214,19 +221,21 @@ export function encodeUserOp (op1: PackedUserOperation | UserOperation, forSigna
   }
   if (forSignature) {
     return defaultAbiCoder.encode(
-      ['address', 'uint256', 'bytes32', 'bytes32',
+      ['bytes32', 'address', 'uint256', 'bytes32', 'bytes32',
         'bytes32', 'uint256', 'bytes32',
         'bytes32'],
-      [op.sender, op.nonce, keccak256(op.initCode), keccak256(op.callData),
+      [PACKED_USEROP_TYPEHASH,
+        op.sender, op.nonce, keccak256(op.initCode), keccak256(op.callData),
         op.accountGasLimits, op.preVerificationGas, op.gasFees,
         keccak256(op.paymasterAndData)])
   } else {
     // for the purpose of calculating gas cost encode also signature (and no keccak of bytes)
     return defaultAbiCoder.encode(
-      ['address', 'uint256', 'bytes', 'bytes',
+      ['bytes32', 'address', 'uint256', 'bytes', 'bytes',
         'bytes32', 'uint256', 'bytes32',
         'bytes', 'bytes'],
-      [op.sender, op.nonce, op.initCode, op.callData,
+      [PACKED_USEROP_TYPEHASH,
+        op.sender, op.nonce, op.initCode, op.callData,
         op.accountGasLimits, op.preVerificationGas, op.gasFees,
         op.paymasterAndData, op.signature])
   }
@@ -242,14 +251,52 @@ export function encodeUserOp (op1: PackedUserOperation | UserOperation, forSigna
  * @param chainId
  */
 export function getUserOpHash (op: UserOperation, entryPoint: string, chainId: number): string {
-  const userOpHash = keccak256(encodeUserOp(op, true))
-  const enc = defaultAbiCoder.encode(
-    ['bytes32', 'address', 'uint256'],
-    [userOpHash, entryPoint, chainId])
-  return keccak256(enc)
+  const packed = encodeUserOp(op, true)
+  return keccak256(hexConcat([
+    '0x1901',
+    getDomainSeparator(entryPoint, chainId),
+    keccak256(packed)
+  ]))
+}
+
+export function getDomainSeparator (entryPoint: string, chainId: number): string {
+  const domainData = getErc4337TypedDataDomain(entryPoint, chainId) as Required<TypedDataDomain>
+  return keccak256(defaultAbiCoder.encode(
+    ['bytes32', 'bytes32', 'bytes32', 'uint256', 'address'],
+    [
+      keccak256(Buffer.from('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)')),
+      keccak256(Buffer.from(domainData.name)),
+      keccak256(Buffer.from(domainData.version)),
+      domainData.chainId,
+      domainData.verifyingContract
+    ]))
+}
+
+export function getErc4337TypedDataDomain (entryPoint: string, chainId: number): TypedDataDomain {
+  return {
+    name: DOMAIN_NAME,
+    version: DOMAIN_VERSION,
+    chainId,
+    verifyingContract: entryPoint
+  }
+}
+
+export function getErc4337TypedDataTypes (): { [type: string]: TypedDataField[] } {
+  return {
+    PackedUserOperation: [
+      { name: 'sender', type: 'address' },
+      { name: 'nonce', type: 'uint256' },
+      { name: 'initCode', type: 'bytes' },
+      { name: 'callData', type: 'bytes' },
+      { name: 'accountGasLimits', type: 'bytes32' },
+      { name: 'preVerificationGas', type: 'uint256' },
+      { name: 'gasFees', type: 'bytes32' },
+      { name: 'paymasterAndData', type: 'bytes' }
+    ]
+  }
 }
 
-const ErrorSig = keccak256(Buffer.from('Error(string)')).slice(0, 10) // 0x08c379a0
+export const ErrorSig = keccak256(Buffer.from('Error(string)')).slice(0, 10) // 0x08c379a0
 const FailedOpSig = keccak256(Buffer.from('FailedOp(uint256,string)')).slice(0, 10) // 0x220266b6
 
 interface DecodedError {

packages/utils/src/Utils.ts

@@ -205,10 +205,10 @@ export async function runContractScript<T extends ContractFactory> (provider: Pr
 }
 
 /**
- * sum the given bignumberish items (numbers, hex, bignumbers)
+ * sum the given bignumberish items (numbers, hex, bignumbers, ignore nulls)
  */
-export function sum (...args: BigNumberish[]): BigNumber {
-  return args.reduce((acc: BigNumber, cur) => acc.add(cur), BigNumber.from(0))
+export function sum (...args: Array<BigNumberish | undefined>): BigNumber {
+  return args.reduce((acc: BigNumber, cur) => acc.add(cur ?? 0), BigNumber.from(0))
 }
 
 /**

packages/utils/src/deployStakeManager.ts

@@ -2,8 +2,7 @@ import { JsonRpcProvider } from '@ethersproject/providers'
 
 import { bytecode as stakeManagerByteCode } from '../artifacts/@account-abstraction/rip7560/contracts/predeploys/Rip7560StakeManager.sol/Rip7560StakeManager.json'
 import { DeterministicDeployer } from './DeterministicDeployer'
-import { Rip7560StakeManager__factory } from './types/factories/@account-abstraction/rip7560/contracts/predeploys'
-import { Rip7560StakeManager } from './types/@account-abstraction/rip7560/contracts/predeploys'
+import { Rip7560StakeManager__factory, Rip7560StakeManager } from './types'
 
 export const stakeManagerSalt = '0x90d8084deab30c2a37c45e8d47f49f2f7965183cb6990a98943ef94940681de3'
 

packages/utils/src/interfaces/EIP7702Authorization.ts

@@ -3,6 +3,7 @@ import RLP from 'rlp'
 import { bytesToHex, ecrecover, hexToBigInt, hexToBytes, PrefixedHexString, pubToAddress } from '@ethereumjs/util'
 import { AddressZero } from '../ERC4337Utils'
 import { keccak256 } from '@ethersproject/keccak256'
+import { toChecksumAddress } from 'ethereumjs-util'
 
 export interface EIP7702Authorization {
   chainId: BigNumberish
@@ -39,7 +40,7 @@ export function getEip7702AuthorizationSigner (authorization: EIP7702Authorizati
     // eslint-disable-next-line @typescript-eslint/no-base-to-string
     hexToBytes(authorization.s.toString() as `0x${string}`)
   )
-  const sender = bytesToHex(pubToAddress(senderPubKey))
+  const sender = toChecksumAddress(bytesToHex(pubToAddress(senderPubKey)))
   if (sender === AddressZero) {
     throw new Error(`Failed to recover authorization for address ${authorization.address}`)
   }

packages/validation-manager/src/GethTracer.ts

@@ -142,6 +142,7 @@ export interface TraceOptions {
   tracer?: LogTracerFunc | string // Setting this will enable JavaScript-based transaction tracing, described below. If set, the previous four arguments will be ignored.
   timeout?: string // Overrides the default timeout of 5 seconds for JavaScript-based tracing calls. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
   stateOverrides?: any
+  blockOverrides?: any
 }
 
 // the result type of debug_traceCall and debug_traceTransaction