@zerodev/permissions 5.4.9 → 5.5.0-beta.0

package/serializeMultiChainPermissionAccounts.ts

@@ -1,6 +1,4 @@
-import type { KernelSmartAccount } from "@zerodev/sdk"
 import { MerkleTree } from "merkletreejs"
-import type { EntryPoint } from "permissionless/types"
 import {
     type Hex,
     concatHex,
@@ -14,17 +12,16 @@ import {
     isPermissionValidatorPlugin,
     serializePermissionAccountParams
 } from "./utils.js"
+import type { SmartAccount } from "viem/account-abstraction"
+import type { KernelSmartAccountImplementation } from "@zerodev/sdk"
 
-export type MultiChainPermissionAccountsParams<entryPoint extends EntryPoint> =
-    {
-        account: KernelSmartAccount<entryPoint>
-        privateKey?: Hex
-    }
+export type MultiChainPermissionAccountsParams = {
+    account: SmartAccount<KernelSmartAccountImplementation>
+    privateKey?: Hex
+}
 
-export const serializeMultiChainPermissionAccounts = async <
-    entryPoint extends EntryPoint
->(
-    params: MultiChainPermissionAccountsParams<entryPoint>[]
+export const serializeMultiChainPermissionAccounts = async (
+    params: MultiChainPermissionAccountsParams[]
 ): Promise<string[]> => {
     if (params.length === 0) return []
 
@@ -33,7 +30,7 @@ export const serializeMultiChainPermissionAccounts = async <
             throw new Error("Account plugin is not a permission validator")
         }
         return (
-            param.account.kernelPluginManager as PermissionPlugin<entryPoint>
+            param.account.kernelPluginManager as PermissionPlugin
         ).getPluginSerializationParams()
     })
 

package/serializePermissionAccount.ts

@@ -1,14 +1,15 @@
-import type { KernelSmartAccount } from "@zerodev/sdk"
-import type { EntryPoint } from "permissionless/types"
 import type { Hex } from "viem"
 import {
     isPermissionValidatorPlugin,
     serializePermissionAccountParams
 } from "./utils.js"
+import type { SmartAccount } from "viem/account-abstraction"
+import type { KernelSmartAccountImplementation } from "@zerodev/sdk"
 
-export const serializePermissionAccount = async <entryPoint extends EntryPoint>(
-    account: KernelSmartAccount<entryPoint>,
-    privateKey?: Hex
+export const serializePermissionAccount = async (
+    account: SmartAccount<KernelSmartAccountImplementation>,
+    privateKey?: Hex,
+    enableSignature?: Hex
 ): Promise<string> => {
     if (!isPermissionValidatorPlugin(account.kernelPluginManager))
         throw new Error("Account plugin is not a permission validator")
@@ -16,10 +17,11 @@ export const serializePermissionAccount = async <entryPoint extends EntryPoint>(
         account.kernelPluginManager.getPluginSerializationParams()
     const action = account.kernelPluginManager.getAction()
     const validityData = account.kernelPluginManager.getValidityData()
-    const enableSignature =
-        await account.kernelPluginManager.getPluginEnableSignature(
+    const _enableSignature =
+        enableSignature ??
+        (await account.kernelPluginManager.getPluginEnableSignature(
             account.address
-        )
+        ))
     const accountParams = {
         initCode: await account.generateInitCode(),
         accountAddress: account.address
@@ -30,7 +32,7 @@ export const serializePermissionAccount = async <entryPoint extends EntryPoint>(
         action,
         validityData,
         accountParams,
-        enableSignature,
+        enableSignature: _enableSignature,
         privateKey
     }
 

package/signers/toECDSASigner.ts

@@ -1,32 +1,24 @@
 import { constants, fixSignedData } from "@zerodev/sdk"
 import type { TypedData } from "abitype"
-import {
-    SignTransactionNotSupportedBySmartAccount,
-    type SmartAccountSigner
-} from "permissionless/accounts"
-import type { Address, LocalAccount, TypedDataDefinition } from "viem"
+import type { LocalAccount, TypedDataDefinition } from "viem"
 import { toAccount } from "viem/accounts"
 import { ECDSA_SIGNER_CONTRACT } from "../constants.js"
 import type { ModularSigner, ModularSignerParams } from "../types.js"
 
-export type ECDSAModularSignerParams<
-    TSource extends string = "custom",
-    TAddress extends Address = Address
-> = ModularSignerParams & {
-    signer: SmartAccountSigner<TSource, TAddress>
+export type ECDSAModularSignerParams = ModularSignerParams & {
+    signer: LocalAccount
 }
 
-export function toECDSASigner<
-    TSource extends string = "custom",
-    TAddress extends Address = Address
->({
+export function toECDSASigner({
     signer,
     signerContractAddress = ECDSA_SIGNER_CONTRACT
-}: ECDSAModularSignerParams<TSource, TAddress>): ModularSigner {
+}: ECDSAModularSignerParams): ModularSigner {
     const viemSigner: LocalAccount = {
         ...signer,
         signTransaction: (_, __) => {
-            throw new SignTransactionNotSupportedBySmartAccount()
+            throw new Error(
+                "Smart account signer doesn't need to sign transactions"
+            )
         }
     } as LocalAccount
     const account = toAccount({
@@ -35,7 +27,9 @@ export function toECDSASigner<
             return fixSignedData(await viemSigner.signMessage({ message }))
         },
         async signTransaction(_, __) {
-            throw new SignTransactionNotSupportedBySmartAccount()
+            throw new Error(
+                "Smart account signer doesn't need to sign transactions"
+            )
         },
         async signTypedData<
             const TTypedData extends TypedData | Record<string, unknown>,

package/signers/toWebAuthnSigner.ts

@@ -10,7 +10,6 @@ import {
     uint8ArrayToHexString
 } from "@zerodev/webauthn-key"
 import type { TypedData } from "abitype"
-import { SignTransactionNotSupportedBySmartAccount } from "permissionless/accounts"
 import {
     type Address,
     type Chain,
@@ -161,7 +160,9 @@ export const toWebAuthnSigner = async <
             ])
         },
         async signTransaction(_, __) {
-            throw new SignTransactionNotSupportedBySmartAccount()
+            throw new Error(
+                "Smart account signer doesn't need to sign transactions"
+            )
         },
         async signTypedData<
             const TTypedData extends TypedData | Record<string, unknown>,

package/toPermissionValidator.ts

@@ -1,12 +1,8 @@
 import { KernelV3AccountAbi } from "@zerodev/sdk"
-import { getEntryPointVersion, getUserOperationHash } from "permissionless"
-import type { EntryPoint } from "permissionless/types/entrypoint"
 import {
     type Address,
-    type Chain,
     type Client,
     type Hex,
-    type Transport,
     concat,
     encodeAbiParameters,
     keccak256,
@@ -23,25 +19,27 @@ import type {
     PermissionPlugin,
     PermissionPluginParams
 } from "./types.js"
+import {
+    getUserOperationHash,
+    type UserOperation,
+    type EntryPointVersion
+} from "viem/account-abstraction"
 
 export async function toPermissionValidator<
-    entryPoint extends EntryPoint,
-    TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined
+    entryPointVersion extends EntryPointVersion
 >(
-    client: Client<TTransport, TChain, undefined>,
+    client: Client,
     {
         signer,
         policies,
-        entryPoint: entryPointAddress,
+        entryPoint,
         kernelVersion: _,
         flag = PolicyFlags.FOR_ALL_VALIDATION
-    }: PermissionPluginParams<entryPoint>
-): Promise<PermissionPlugin<entryPoint>> {
+    }: PermissionPluginParams<entryPointVersion>
+): Promise<PermissionPlugin> {
     const chainId = await getChainId(client)
-    const entryPointVersion = getEntryPointVersion(entryPointAddress)
 
-    if (entryPointVersion !== "v0.7") {
+    if (entryPoint.version !== "0.7") {
         throw new Error("Only EntryPoint 0.7 is supported")
     }
 
@@ -101,8 +99,12 @@ export async function toPermissionValidator<
 
         signUserOperation: async (userOperation): Promise<Hex> => {
             const userOpHash = getUserOperationHash({
-                userOperation: { ...userOperation, signature: "0x" },
-                entryPoint: entryPointAddress,
+                userOperation: {
+                    ...userOperation,
+                    signature: "0x"
+                } as UserOperation<entryPointVersion>,
+                entryPointAddress: entryPoint.address,
+                entryPointVersion: entryPoint.version,
                 chainId
             })
 
@@ -119,7 +121,7 @@ export async function toPermissionValidator<
             return 0n
         },
 
-        async getDummySignature(_userOperation) {
+        async getStubSignature(_userOperation) {
             return concat(["0xff", signer.getDummySignature()])
         },
         getPluginSerializationParams: (): PermissionData => {

package/types.ts

@@ -4,7 +4,6 @@ import type {
     GetKernelVersion,
     PluginValidityData
 } from "@zerodev/sdk/types"
-import type { EntryPoint } from "permissionless/types/entrypoint"
 import type { Abi, Address, Hex, LocalAccount } from "viem"
 import type { PolicyFlags } from "./constants.js"
 import type {
@@ -15,11 +14,9 @@ import type {
     SudoPolicyParams,
     TimestampPolicyParams
 } from "./policies/index.js"
+import type { EntryPointVersion } from "viem/account-abstraction"
 
-export type PermissionPlugin<entryPoint extends EntryPoint> = KernelValidator<
-    entryPoint,
-    "PermissionValidator"
-> & {
+export type PermissionPlugin = KernelValidator<"PermissionValidator"> & {
     getPluginSerializationParams: () => PermissionData
 }
 
@@ -53,11 +50,13 @@ export type Policy = {
         | (TimestampPolicyParams & { type: "timestamp" })
 }
 
-export type PermissionPluginParams<entryPoint extends EntryPoint> = {
+export type PermissionPluginParams<
+    entryPointVersion extends EntryPointVersion
+> = {
     signer: ModularSigner
     policies: Policy[]
-    entryPoint: entryPoint
-    kernelVersion: GetKernelVersion<entryPoint>
+    entryPoint: { address: Address; version: entryPointVersion }
+    kernelVersion: GetKernelVersion<entryPointVersion>
     flag?: PolicyFlags
 }
 

package/utils.ts

@@ -1,4 +1,3 @@
-import type { EntryPoint } from "permissionless/types"
 import type { PermissionAccountParams, PermissionPlugin } from "./types.js"
 
 export function base64ToBytes(base64: string) {
@@ -11,10 +10,10 @@ export function bytesToBase64(bytes: Uint8Array) {
     return btoa(binString)
 }
 
-export function isPermissionValidatorPlugin<entryPoint extends EntryPoint>(
+export function isPermissionValidatorPlugin(
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     plugin: any
-): plugin is PermissionPlugin<entryPoint> {
+): plugin is PermissionPlugin {
     return plugin?.getPluginSerializationParams !== undefined
 }