permissionless 0.0.35 → 0.1.0

package/utils/getUserOperationHash.ts

@@ -1,11 +1,86 @@
 import type { Address, Hash, Hex } from "viem"
-import { encodeAbiParameters, keccak256 } from "viem"
+import { concat, encodeAbiParameters, keccak256, pad, toHex } from "viem"
+import type { EntryPoint, GetEntryPointVersion } from "../types"
 import type { UserOperation } from "../types/userOperation"
+import { getEntryPointVersion } from "./getEntryPointVersion"
 
-function packUserOp({ userOperation }: { userOperation: UserOperation }): Hex {
-    const hashedInitCode = keccak256(userOperation.initCode)
-    const hashedCallData = keccak256(userOperation.callData)
-    const hashedPaymasterAndData = keccak256(userOperation.paymasterAndData)
+function packUserOp<entryPoint extends EntryPoint>({
+    userOperation,
+    entryPoint: entryPointAddress
+}: {
+    userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+    entryPoint: entryPoint
+}): Hex {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (entryPointVersion === "v0.6") {
+        const userOperationVersion0_6 = userOperation as UserOperation<"v0.6">
+        const hashedInitCode = keccak256(userOperationVersion0_6.initCode)
+        const hashedCallData = keccak256(userOperationVersion0_6.callData)
+        const hashedPaymasterAndData = keccak256(
+            userOperationVersion0_6.paymasterAndData
+        )
+
+        return encodeAbiParameters(
+            [
+                { type: "address" },
+                { type: "uint256" },
+                { type: "bytes32" },
+                { type: "bytes32" },
+                { type: "uint256" },
+                { type: "uint256" },
+                { type: "uint256" },
+                { type: "uint256" },
+                { type: "uint256" },
+                { type: "bytes32" }
+            ],
+            [
+                userOperationVersion0_6.sender as Address,
+                userOperationVersion0_6.nonce,
+                hashedInitCode,
+                hashedCallData,
+                userOperationVersion0_6.callGasLimit,
+                userOperationVersion0_6.verificationGasLimit,
+                userOperationVersion0_6.preVerificationGas,
+                userOperationVersion0_6.maxFeePerGas,
+                userOperationVersion0_6.maxPriorityFeePerGas,
+                hashedPaymasterAndData
+            ]
+        )
+    }
+
+    const userOperationVersion0_7 = userOperation as UserOperation<"v0.7">
+    const hashedInitCode = keccak256(
+        userOperationVersion0_7.factory && userOperationVersion0_7.factoryData
+            ? concat([
+                  userOperationVersion0_7.factory,
+                  userOperationVersion0_7.factoryData
+              ])
+            : "0x"
+    )
+    const hashedCallData = keccak256(userOperationVersion0_7.callData)
+    const hashedPaymasterAndData = keccak256(
+        userOperationVersion0_7.paymaster &&
+            userOperationVersion0_7.paymasterVerificationGasLimit &&
+            userOperationVersion0_7.paymasterPostOpGasLimit &&
+            userOperationVersion0_7.paymasterData
+            ? concat([
+                  userOperationVersion0_7.paymaster,
+                  pad(
+                      toHex(
+                          userOperationVersion0_7.paymasterVerificationGasLimit
+                      ),
+                      {
+                          size: 16
+                      }
+                  ),
+                  pad(toHex(userOperationVersion0_7.paymasterPostOpGasLimit), {
+                      size: 16
+                  }),
+                  userOperationVersion0_7.paymasterData
+              ])
+            : "0x"
+    )
 
     return encodeAbiParameters(
         [
@@ -13,31 +88,37 @@ function packUserOp({ userOperation }: { userOperation: UserOperation }): Hex {
             { type: "uint256" },
             { type: "bytes32" },
             { type: "bytes32" },
+            { type: "bytes32" },
             { type: "uint256" },
-            { type: "uint256" },
-            { type: "uint256" },
-            { type: "uint256" },
-            { type: "uint256" },
+            { type: "bytes32" },
             { type: "bytes32" }
         ],
         [
-            userOperation.sender as Address,
-            userOperation.nonce,
+            userOperationVersion0_7.sender as Address,
+            userOperationVersion0_7.nonce,
             hashedInitCode,
             hashedCallData,
-            userOperation.callGasLimit,
-            userOperation.verificationGasLimit,
-            userOperation.preVerificationGas,
-            userOperation.maxFeePerGas,
-            userOperation.maxPriorityFeePerGas,
+            concat([
+                pad(toHex(userOperationVersion0_7.verificationGasLimit), {
+                    size: 16
+                }),
+                pad(toHex(userOperationVersion0_7.callGasLimit), { size: 16 })
+            ]),
+            userOperationVersion0_7.preVerificationGas,
+            concat([
+                pad(toHex(userOperationVersion0_7.maxPriorityFeePerGas), {
+                    size: 16
+                }),
+                pad(toHex(userOperationVersion0_7.maxFeePerGas), { size: 16 })
+            ]),
             hashedPaymasterAndData
         ]
     )
 }
 
-export type GetUserOperationHashParams = {
-    userOperation: UserOperation
-    entryPoint: Address
+export type GetUserOperationHashParams<entryPoint extends EntryPoint> = {
+    userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+    entryPoint: entryPoint
     chainId: number
 }
 
@@ -62,14 +143,23 @@ export type GetUserOperationHashParams = {
  * // Returns "0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34"
  *
  */
-export const getUserOperationHash = ({
+export const getUserOperationHash = <entryPoint extends EntryPoint>({
     userOperation,
-    entryPoint,
+    entryPoint: entryPointAddress,
     chainId
-}: GetUserOperationHashParams): Hash => {
+}: GetUserOperationHashParams<entryPoint>): Hash => {
     const encoded = encodeAbiParameters(
         [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
-        [keccak256(packUserOp({ userOperation })), entryPoint, BigInt(chainId)]
+        [
+            keccak256(
+                packUserOp<entryPoint>({
+                    userOperation,
+                    entryPoint: entryPointAddress
+                })
+            ),
+            entryPointAddress,
+            BigInt(chainId)
+        ]
     ) as `0x${string}`
 
     return keccak256(encoded)

package/utils/index.ts

@@ -24,6 +24,11 @@ export function parseAccount(account: Address | Account): Account {
         return { address: account, type: "json-rpc" }
     return account
 }
+import {
+    ENTRYPOINT_ADDRESS_V06,
+    ENTRYPOINT_ADDRESS_V07,
+    getEntryPointVersion
+} from "./getEntryPointVersion"
 
 export {
     transactionReceiptStatus,
@@ -39,5 +44,8 @@ export {
     AccountOrClientNotFoundError,
     isSmartAccountDeployed,
     providerToSmartAccountSigner,
-    getAddressFromInitCodeOrPaymasterAndData
+    getAddressFromInitCodeOrPaymasterAndData,
+    getEntryPointVersion,
+    ENTRYPOINT_ADDRESS_V06,
+    ENTRYPOINT_ADDRESS_V07
 }

package/utils/providerToSmartAccountSigner.ts

@@ -6,10 +6,13 @@ import {
 } from "viem"
 import { walletClientToSmartAccountSigner } from "./walletClientToSmartAccountSigner"
 
-export const providerToSmartAccountSigner = async (
-    provider: EIP1193Provider,
+export const providerToSmartAccountSigner = async ({
+    provider,
+    signerAddress
+}: {
+    provider: EIP1193Provider
     signerAddress?: Hex
-) => {
+}) => {
     let account: Hex
     if (!signerAddress) {
         ;[account] = await provider.request({ method: "eth_requestAccounts" })

package/utils/signUserOperationHashWithECDSA.ts

@@ -1,6 +1,5 @@
 import {
     type Account,
-    type Address,
     BaseError,
     type Chain,
     type Client,
@@ -8,12 +7,17 @@ import {
     type Hex,
     type Transport
 } from "viem"
-import { type GetAccountParameterWithClient } from "../types/"
+import type {
+    EntryPoint,
+    GetAccountParameterWithClient,
+    GetEntryPointVersion
+} from "../types/"
 import type { UserOperation } from "../types/userOperation"
 import { parseAccount } from "./"
 import { getUserOperationHash } from "./getUserOperationHash"
 
 export type SignUserOperationHashWithECDSAParams<
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
@@ -27,8 +31,8 @@ export type SignUserOperationHashWithECDSAParams<
           }
         | {
               hash?: undefined
-              userOperation: UserOperation
-              entryPoint: Address
+              userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+              entryPoint: entryPoint
               chainId: number
           }
     )
@@ -73,6 +77,7 @@ export class AccountOrClientNotFoundError extends BaseError {
  *
  */
 export const signUserOperationHashWithECDSA = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
@@ -82,8 +87,9 @@ export const signUserOperationHashWithECDSA = async <
     hash,
     userOperation,
     chainId,
-    entryPoint
+    entryPoint: entryPointAddress
 }: SignUserOperationHashWithECDSAParams<
+    entryPoint,
     TTransport,
     TChain,
     TAccount
@@ -99,10 +105,10 @@ export const signUserOperationHashWithECDSA = async <
     if (hash) {
         userOperationHash = hash
     } else {
-        userOperationHash = getUserOperationHash({
+        userOperationHash = getUserOperationHash<entryPoint>({
             userOperation,
             chainId,
-            entryPoint
+            entryPoint: entryPointAddress
         })
     }