@zerodev/permissions 5.2.1-alpha.0

package/_types/signers/index.d.ts

@@ -0,0 +1,5 @@
+export { toECDSASigner, type ECDSAModularSignerParams } from "./toECDSASigner.js";
+export { toWebAuthnSigner, type WebAuthnModularSignerParams } from "./toWebAuthnSigner.js";
+export { WebAuthnMode } from "./toWebAuthnPubKey.js";
+export { toSignerId } from "./utils/toSignerId.js";
+//# sourceMappingURL=index.d.ts.map

package/_types/signers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../signers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EACb,KAAK,wBAAwB,EAChC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACH,gBAAgB,EAChB,KAAK,2BAA2B,EACnC,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA"}

package/_types/signers/toECDSASigner.d.ts

@@ -0,0 +1,8 @@
+import { type SmartAccountSigner } from "permissionless/accounts";
+import { type Address } from "viem";
+import type { ModularSigner, ModularSignerParams } from "../types.js";
+export type ECDSAModularSignerParams<TSource extends string = "custom", TAddress extends Address = Address> = ModularSignerParams & {
+    signer: SmartAccountSigner<TSource, TAddress>;
+};
+export declare function toECDSASigner<TSource extends string = "custom", TAddress extends Address = Address>({ signer, signerContractAddress }: ECDSAModularSignerParams<TSource, TAddress>): ModularSigner;
+//# sourceMappingURL=toECDSASigner.d.ts.map

package/_types/signers/toECDSASigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toECDSASigner.d.ts","sourceRoot":"","sources":["../../signers/toECDSASigner.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,kBAAkB,EAC1B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,KAAK,OAAO,EAA+C,MAAM,MAAM,CAAA;AAGhF,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAErE,MAAM,MAAM,wBAAwB,CAChC,OAAO,SAAS,MAAM,GAAG,QAAQ,EACjC,QAAQ,SAAS,OAAO,GAAG,OAAO,IAClC,mBAAmB,GAAG;IACtB,MAAM,EAAE,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;CAChD,CAAA;AAED,wBAAgB,aAAa,CACzB,OAAO,SAAS,MAAM,GAAG,QAAQ,EACjC,QAAQ,SAAS,OAAO,GAAG,OAAO,EACpC,EACE,MAAM,EACN,qBAA6C,EAChD,EAAE,wBAAwB,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,aAAa,CAoC7D"}

package/_types/signers/toWebAuthnPubKey.d.ts

@@ -0,0 +1,11 @@
+import { type WebAuthnKey } from "./toWebAuthnSigner.js";
+export declare enum WebAuthnMode {
+    Register = "register",
+    Login = "login"
+}
+export declare const toWebAuthnPubKey: ({ passkeyName, passkeyServerUrl, mode }: {
+    passkeyName: string;
+    passkeyServerUrl: string;
+    mode: WebAuthnMode;
+}) => Promise<WebAuthnKey>;
+//# sourceMappingURL=toWebAuthnPubKey.d.ts.map

package/_types/signers/toWebAuthnPubKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toWebAuthnPubKey.d.ts","sourceRoot":"","sources":["../../signers/toWebAuthnPubKey.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,oBAAY,YAAY;IACpB,QAAQ,aAAa;IACrB,KAAK,UAAU;CAClB;AAED,eAAO,MAAM,gBAAgB;iBAKZ,MAAM;sBACD,MAAM;UAClB,YAAY;MAClB,QAAQ,WAAW,CAoItB,CAAA"}

package/_types/signers/toWebAuthnSigner.d.ts

@@ -0,0 +1,16 @@
+import { type Chain, type Client, type Hex, type Transport } from "viem";
+import type { ModularSigner, ModularSignerParams } from "../types.js";
+import { WebAuthnMode } from "./toWebAuthnPubKey.js";
+export type WebAuthnKey = {
+    pubX: bigint;
+    pubY: bigint;
+    authenticatorIdHash: Hex;
+};
+export type WebAuthnModularSignerParams = ModularSignerParams & {
+    passkeyName: string;
+    passkeyServerUrl: string;
+    pubKey?: WebAuthnKey;
+    mode?: WebAuthnMode;
+};
+export declare const toWebAuthnSigner: <TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined>(client: Client<TTransport, TChain, undefined>, { signerContractAddress, pubKey, passkeyServerUrl, passkeyName, mode }: WebAuthnModularSignerParams) => Promise<ModularSigner>;
+//# sourceMappingURL=toWebAuthnSigner.d.ts.map

package/_types/signers/toWebAuthnSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toWebAuthnSigner.d.ts","sourceRoot":"","sources":["../../signers/toWebAuthnSigner.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,KAAK,EACV,KAAK,MAAM,EACX,KAAK,GAAG,EAGR,KAAK,SAAS,EAKjB,MAAM,MAAM,CAAA;AAKb,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,EAAE,YAAY,EAAoB,MAAM,uBAAuB,CAAA;AAStE,MAAM,MAAM,WAAW,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,mBAAmB,EAAE,GAAG,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG,mBAAmB,GAAG;IAC5D,WAAW,EAAE,MAAM,CAAA;IACnB,gBAAgB,EAAE,MAAM,CAAA;IACxB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,IAAI,CAAC,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,gBAAgB,0NAWtB,2BAA2B,KAC/B,QAAQ,aAAa,CA6LvB,CAAA"}

package/_types/signers/utils/toSignerId.d.ts

@@ -0,0 +1,4 @@
+import { type Hex } from "viem";
+import type { ModularSigner } from "../../types.js";
+export declare const toSignerId: (signer: ModularSigner) => Hex;
+//# sourceMappingURL=toSignerId.d.ts.map

package/_types/signers/utils/toSignerId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSignerId.d.ts","sourceRoot":"","sources":["../../../signers/utils/toSignerId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAA+B,MAAM,MAAM,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,eAAO,MAAM,UAAU,WAAY,aAAa,KAAG,GAKlD,CAAA"}

package/_types/signers/webAuthnUtils.d.ts

@@ -0,0 +1,13 @@
+import { type Hex } from "viem";
+export declare const uint8ArrayToHexString: (array: Uint8Array) => `0x${string}`;
+export declare const b64ToBytes: (base64: string) => Uint8Array;
+export declare const findQuoteIndices: (input: string) => {
+    beforeType: bigint;
+    beforeChallenge: bigint;
+};
+export declare function parseAndNormalizeSig(derSig: Hex): {
+    r: bigint;
+    s: bigint;
+};
+export declare const isRIP7212SupportedNetwork: (chainId: number) => boolean;
+//# sourceMappingURL=webAuthnUtils.d.ts.map

package/_types/signers/webAuthnUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webAuthnUtils.d.ts","sourceRoot":"","sources":["../../signers/webAuthnUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAA6B,MAAM,MAAM,CAAA;AAI1D,eAAO,MAAM,qBAAqB,UAAW,UAAU,KAAG,KAAK,MAAM,EAIpE,CAAA;AAED,eAAO,MAAM,UAAU,WAAY,MAAM,KAAG,UAO3C,CAAA;AAED,eAAO,MAAM,gBAAgB,UAClB,MAAM,KACd;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAO/C,CAAA;AAID,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,GAAG,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAiB1E;AAED,eAAO,MAAM,yBAAyB,YAAa,MAAM,KAAG,OACZ,CAAA"}

package/_types/toPermissionValidator.d.ts

@@ -0,0 +1,5 @@
+import type { EntryPoint } from "permissionless/types/entrypoint";
+import { type Chain, type Client, type Transport } from "viem";
+import type { PermissionPlugin, PermissionPluginParams } from "./types.js";
+export declare function toPermissionValidator<entryPoint extends EntryPoint, TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined>(client: Client<TTransport, TChain, undefined>, { signer, policies, entryPoint: entryPointAddress, flag }: PermissionPluginParams): Promise<PermissionPlugin<entryPoint>>;
+//# sourceMappingURL=toPermissionValidator.d.ts.map

package/_types/toPermissionValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPermissionValidator.d.ts","sourceRoot":"","sources":["../toPermissionValidator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAEH,KAAK,KAAK,EACV,KAAK,MAAM,EAEX,KAAK,SAAS,EAOjB,MAAM,MAAM,CAAA;AAKb,OAAO,KAAK,EAER,gBAAgB,EAChB,sBAAsB,EACzB,MAAM,YAAY,CAAA;AAEnB,wBAAsB,qBAAqB,CACvC,UAAU,SAAS,UAAU,EAC7B,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EAEpD,MAAM,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,EAC7C,EACI,MAAM,EACN,QAAQ,EACR,UAAU,EAAE,iBAAiB,EAC7B,IAAqC,EACxC,EAAE,sBAAsB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAiHvC"}

package/_types/types.d.ts

@@ -0,0 +1,49 @@
+import { type KernelValidator } from "@zerodev/sdk";
+import type { Action, PluginValidityData } from "@zerodev/sdk/types";
+import type { EntryPoint } from "permissionless/types/entrypoint";
+import type { Abi, Address, Hex, LocalAccount } from "viem";
+import { PolicyFlags } from "./constants.js";
+import type { CallPolicyParams, GasPolicyParams, RateLimitPolicyParams, SignatureCallerPolicyParams, SudoPolicyParams } from "./policies/index.js";
+export type PermissionPlugin<entryPoint extends EntryPoint> = KernelValidator<entryPoint, "PermissionValidator"> & {
+    getPluginSerializationParams: () => PermissionData;
+};
+export type ModularSignerParams = {
+    signerContractAddress?: Address;
+};
+export type PolicyParams = {
+    policyAddress?: Address;
+    policyFlag?: PolicyFlags;
+};
+export type ModularSigner = {
+    account: LocalAccount;
+    signerContractAddress: Address;
+    getSignerData: (permissionId?: Hex) => Hex;
+    getDummySignature: () => Hex;
+};
+export type Policy = {
+    getPolicyData: (permissionId?: Hex) => Hex;
+    getPolicyInfoInBytes: () => Hex;
+    policyParams: CallPolicyParams<Abi | readonly unknown[], string> | GasPolicyParams | RateLimitPolicyParams | SignatureCallerPolicyParams | SudoPolicyParams;
+};
+export type PermissionPluginParams = {
+    signer: ModularSigner;
+    policies: Policy[];
+    entryPoint: EntryPoint;
+    flag?: PolicyFlags;
+};
+export interface PermissionData {
+    policies?: Policy[];
+}
+export type ExportPermissionAccountParams = {
+    initCode: Hex;
+    accountAddress: Address;
+};
+export type PermissionAccountParams = {
+    permissionParams: PermissionData;
+    action: Action;
+    validityData: PluginValidityData;
+    accountParams: ExportPermissionAccountParams;
+    enableSignature?: Hex;
+    privateKey?: Hex;
+};
+//# sourceMappingURL=types.d.ts.map

package/_types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EACR,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,2BAA2B,EAC3B,gBAAgB,EACnB,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,gBAAgB,CAAC,UAAU,SAAS,UAAU,IAAI,eAAe,CACzE,UAAU,EACV,qBAAqB,CACxB,GAAG;IACA,4BAA4B,EAAE,MAAM,cAAc,CAAA;CACrD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAClC,CAAA;AACD,MAAM,MAAM,YAAY,GAAG;IACvB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,UAAU,CAAC,EAAE,WAAW,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IACxB,OAAO,EAAE,YAAY,CAAA;IACrB,qBAAqB,EAAE,OAAO,CAAA;IAC9B,aAAa,EAAE,CAAC,YAAY,CAAC,EAAE,GAAG,KAAK,GAAG,CAAA;IAC1C,iBAAiB,EAAE,MAAM,GAAG,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,aAAa,EAAE,CAAC,YAAY,CAAC,EAAE,GAAG,KAAK,GAAG,CAAA;IAC1C,oBAAoB,EAAE,MAAM,GAAG,CAAA;IAE/B,YAAY,EACN,gBAAgB,CAAC,GAAG,GAAG,SAAS,OAAO,EAAE,EAAE,MAAM,CAAC,GAClD,eAAe,GACf,qBAAqB,GACrB,2BAA2B,GAC3B,gBAAgB,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACjC,MAAM,EAAE,aAAa,CAAA;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,UAAU,EAAE,UAAU,CAAA;IACtB,IAAI,CAAC,EAAE,WAAW,CAAA;CACrB,CAAA;AAED,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED,MAAM,MAAM,6BAA6B,GAAG;IACxC,QAAQ,EAAE,GAAG,CAAA;IACb,cAAc,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IAClC,gBAAgB,EAAE,cAAc,CAAA;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,kBAAkB,CAAA;IAChC,aAAa,EAAE,6BAA6B,CAAA;IAC5C,eAAe,CAAC,EAAE,GAAG,CAAA;IACrB,UAAU,CAAC,EAAE,GAAG,CAAA;CACnB,CAAA"}

package/_types/utils.d.ts

@@ -0,0 +1,8 @@
+import type { EntryPoint } from "permissionless/types";
+import type { PermissionAccountParams, PermissionPlugin } from "./types.js";
+export declare function base64ToBytes(base64: string): Uint8Array;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function isPermissionValidatorPlugin<entryPoint extends EntryPoint>(plugin: any): plugin is PermissionPlugin<entryPoint>;
+export declare const serializePermissionAccountParams: (params: PermissionAccountParams) => string;
+export declare const deserializePermissionAccountParams: (params: string) => PermissionAccountParams;
+//# sourceMappingURL=utils.d.ts.map

package/_types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE3E,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,cAG3C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,UAG9C;AAED,wBAAgB,2BAA2B,CAAC,UAAU,SAAS,UAAU,EAErE,MAAM,EAAE,GAAG,GACZ,MAAM,IAAI,gBAAgB,CAAC,UAAU,CAAC,CAExC;AAED,eAAO,MAAM,gCAAgC,WACjC,uBAAuB,WAclC,CAAA;AAED,eAAO,MAAM,kCAAkC,WAAY,MAAM,4BAIhE,CAAA"}

package/constants.ts

@@ -0,0 +1,17 @@
+export const CALL_POLICY_CONTRACT = "0xc4a1aaED053Fc02717358a377A2d695bCdFA3B8A"
+export const ECDSA_SIGNER_CONTRACT =
+    "0x8Ed04D0B000777c87e701696cf6B9710733Df96a"
+export const GAS_POLICY_CONTRACT = "0x50FD84A0A1D1683e1dafC5009876B38773fc8E3A"
+export const SIGNATURE_POLICY_CONTRACT =
+    "0x19a3E696fFdFEDfadb22297DB223B9ca501523dD"
+export const RATE_LIMIT_POLICY_CONTRACT =
+    "0xdB6e5F9a18f0F6Fa0861cB60f94Cf7f7374E8270"
+export const WEBAUTHN_SIGNER_CONTRACT =
+    "0xD71E0e2AFf9D4d93b20F615e6aC2ac7e0795b472"
+export const SUDO_POLICY_CONTRACT = "0x6D14FC570e2bE7D74a6926ea54f190d690855851"
+
+export enum PolicyFlags {
+    FOR_ALL_VALIDATION = "0x0000",
+    NOT_FOR_VALIDATE_USEROP = "0x0001",
+    NOT_FOR_VALIDATE_SIG = "0x0002"
+}

package/deserializePermissionAccount.ts

@@ -0,0 +1,119 @@
+import { KernelV3AccountAbi, createKernelAccount } from "@zerodev/sdk"
+import { KernelFactoryAbi } from "@zerodev/sdk"
+import { toKernelPluginManager } from "@zerodev/sdk/accounts"
+import type { ValidatorInitData } from "@zerodev/sdk/types"
+import { ENTRYPOINT_ADDRESS_V06 } from "permissionless"
+import type { EntryPoint } from "permissionless/types"
+import type { Hex } from "viem"
+import { decodeFunctionData } from "viem"
+import { privateKeyToAccount } from "viem/accounts"
+import {
+    toCallPolicy,
+    toGasPolicy,
+    toRateLimitPolicy,
+    toSignatureCallerPolicy,
+    toSudoPolicy
+} from "./policies/index.js"
+import { toECDSASigner } from "./signers/toECDSASigner.js"
+import { toPermissionValidator } from "./toPermissionValidator.js"
+import { type Policy } from "./types.js"
+import type { ModularSigner } from "./types.js"
+import { deserializePermissionAccountParams } from "./utils.js"
+
+export const deserializePermissionAccount = async <
+    entryPoint extends EntryPoint
+>(
+    client: Parameters<typeof createKernelAccount>[0],
+    modularPermissionAccountParams: string,
+    modularSigner?: ModularSigner,
+    entryPointAddress: entryPoint = ENTRYPOINT_ADDRESS_V06 as entryPoint
+) => {
+    const params = deserializePermissionAccountParams(
+        modularPermissionAccountParams
+    )
+    let signer: ModularSigner
+    if (params.privateKey)
+        signer = toECDSASigner({
+            signer: privateKeyToAccount(params.privateKey)
+        })
+    else if (modularSigner) signer = modularSigner
+    else throw new Error("No signer or serialized sessionKey provided")
+
+    const modularPermissionPlugin = await toPermissionValidator(client, {
+        signer,
+        policies: await Promise.all(
+            params.permissionParams.policies?.map((policy) =>
+                createPolicyFromParams(policy)
+            ) || []
+        ),
+        entryPoint: entryPointAddress
+    })
+
+    const { index, validatorInitData } = decodeParamsFromInitCode(
+        params.accountParams.initCode
+    )
+
+    const kernelPluginManager = await toKernelPluginManager<entryPoint>(
+        client,
+        {
+            regular: modularPermissionPlugin,
+            pluginEnableSignature: params.enableSignature,
+            validatorInitData,
+            action: params.action,
+            entryPoint: entryPointAddress,
+            ...params.validityData
+        }
+    )
+
+    return createKernelAccount<entryPoint>(client, {
+        plugins: kernelPluginManager,
+        index,
+        deployedAccountAddress: params.accountParams.accountAddress,
+        entryPoint: entryPointAddress
+    })
+}
+
+export const createPolicyFromParams = async (policy: Policy) => {
+    switch (policy.policyParams.type) {
+        case "call":
+            return await toCallPolicy(policy.policyParams)
+        case "gas":
+            return await toGasPolicy(policy.policyParams)
+        case "rate-limit":
+            return await toRateLimitPolicy(policy.policyParams)
+        case "signature-caller":
+            return await toSignatureCallerPolicy(policy.policyParams)
+        case "sudo":
+            return await toSudoPolicy(policy.policyParams)
+        default:
+            throw new Error("Unsupported policy type")
+    }
+}
+
+export const decodeParamsFromInitCode = (initCode: Hex) => {
+    let index: bigint | undefined
+    let validatorInitData: ValidatorInitData | undefined
+    const createAccountFunctionData = decodeFunctionData({
+        abi: KernelFactoryAbi,
+        data: `0x${initCode.slice(42)}`
+    })
+    if (!createAccountFunctionData) throw new Error("Invalid initCode")
+    if (createAccountFunctionData.functionName === "createAccount") {
+        index = createAccountFunctionData.args[2]
+        const initializeFunctionData = decodeFunctionData({
+            abi: KernelV3AccountAbi,
+            data: createAccountFunctionData.args[1]
+        })
+        if (!initializeFunctionData) throw new Error("Invalid initCode")
+        if (initializeFunctionData.functionName === "initialize") {
+            validatorInitData = {
+                validatorAddress: initializeFunctionData.args[0],
+                identifier: initializeFunctionData.args[0],
+                enableData: initializeFunctionData.args[2]
+            }
+        }
+    }
+    if (index === undefined || validatorInitData === undefined)
+        throw new Error("Invalid initCode")
+    return { index, validatorInitData }
+}

package/index.ts

@@ -0,0 +1,5 @@
+export type * from "./types.js"
+export { toPermissionValidator } from "./toPermissionValidator.js"
+export { serializePermissionAccount } from "./serializePermissionAccount.js"
+export { deserializePermissionAccount } from "./deserializePermissionAccount.js"
+export * from "./constants.js"

package/package.json

@@ -0,0 +1,63 @@
+{
+    "name": "@zerodev/permissions",
+    "version": "5.2.1-alpha.0",
+    "author": "ZeroDev",
+    "main": "./_cjs/index.js",
+    "module": "./_esm/index.js",
+    "types": "./_types/index.d.ts",
+    "typings": "./_types/index.d.ts",
+    "type": "module",
+    "sideEffects": false,
+    "license": "MIT",
+    "files": [
+        "_esm",
+        "_cjs",
+        "_types",
+        "./**/*.ts",
+        "!_esm/**/*.tsbuildinfo",
+        "!_cjs/**/*.tsbuildinfo",
+        "!_types/**/*.tsbuildinfo",
+        "!.env",
+        "!./**/*.test.ts",
+        "!.changeset"
+    ],
+    "scripts": {
+        "build": "bun run clean && bun run build:cjs && bun run build:esm && bun run build:types",
+        "build:cjs": "tsc --project ./tsconfig.build.json --module commonjs --outDir ./_cjs --removeComments --verbatimModuleSyntax false && printf '{\"type\":\"commonjs\"}' > ./_cjs/package.json",
+        "build:esm": "tsc --project ./tsconfig.build.json --module es2015 --outDir ./_esm && printf '{\"type\": \"module\",\"sideEffects\":false}' > ./_esm/package.json",
+        "build:types": "tsc --project ./tsconfig.build.json --module esnext --declarationDir ./_types --emitDeclarationOnly --declaration --declarationMap",
+        "clean": "rimraf _esm _cjs _types",
+        "changeset": "changeset",
+        "changeset:release": "bun run build && changeset publish",
+        "changeset:version": "changeset version && bun install --lockfile-only",
+        "format": "biome format . --write",
+        "lint": "biome check .",
+        "lint:fix": "bun run lint --apply"
+    },
+    "exports": {
+        ".": {
+            "types": "./_types/index.d.ts",
+            "import": "./_esm/index.js",
+            "default": "./_cjs/index.js"
+        },
+        "./policies": {
+            "types": "./_types/policies/index.d.ts",
+            "import": "./_esm/policies/index.js",
+            "default": "./_cjs/policies/index.js"
+        },
+        "./signers": {
+            "types": "./_types/signers/index.d.ts",
+            "import": "./_esm/signers/index.js",
+            "default": "./_cjs/signers/index.js"
+        }
+    },
+    "dependencies": {
+        "merkletreejs": "^0.3.11",
+        "@simplewebauthn/browser": "^9.0.1"
+    },
+    "peerDependencies": {
+        "viem": "^2.0.0",
+        "@zerodev/sdk": "^5.2.1-alpha-0",
+        "permissionless": "^0.1.4"
+    }
+}

package/policies/callPolicyUtils.ts

@@ -0,0 +1,122 @@
+import {
+    type Abi,
+    type AbiFunction,
+    type GetAbiItemParameters,
+    type Hex,
+    encodeAbiParameters,
+    getAbiItem,
+    isHex,
+    pad,
+    toFunctionSelector,
+    toHex
+} from "viem"
+import type {
+    CombinedArgs,
+    GeneratePermissionFromArgsParameters,
+    ParamRule,
+    PermissionCore
+} from "./types.js"
+
+export function getPermissionFromABI<
+    TAbi extends Abi | readonly unknown[],
+    TFunctionName extends string | undefined = string
+>({
+    abi,
+    args,
+    functionName
+}: GeneratePermissionFromArgsParameters<TAbi, TFunctionName>): Pick<
+    PermissionCore,
+    "selector" | "rules"
+> {
+    if (!abi || !functionName) {
+        return {
+            selector: undefined,
+            rules: undefined
+        }
+    }
+    const abiItem = getAbiItem({
+        abi,
+        args,
+        name: functionName
+    } as GetAbiItemParameters)
+    if (abiItem?.type !== "function") {
+        throw Error(`${functionName} not found in abi`)
+    }
+    const functionSelector = toFunctionSelector(abiItem)
+    let paramRules: ParamRule[] = []
+    if (args && Array.isArray(args)) {
+        paramRules = (args as CombinedArgs<AbiFunction["inputs"]>)
+            .map(
+                (arg, i) =>
+                    arg && {
+                        param: pad(
+                            isHex(arg.value)
+                                ? arg.value
+                                : toHex(
+                                      arg.value as Parameters<typeof toHex>[0]
+                                  ),
+                            { size: 32 }
+                        ),
+                        offset: i * 32,
+                        condition: arg.condition
+                    }
+            )
+            .filter((rule) => rule) as ParamRule[]
+    }
+    return {
+        selector: functionSelector,
+        rules: paramRules
+    }
+}
+
+export const encodePermissionData = (
+    permission: PermissionCore | PermissionCore[]
+): Hex => {
+    const permissionParam = {
+        components: [
+            {
+                internalType: "enum CallType",
+                name: "callType",
+                type: "bytes1"
+            },
+            {
+                name: "target",
+                type: "address"
+            },
+            {
+                name: "selector",
+                type: "bytes4"
+            },
+            {
+                name: "valueLimit",
+                type: "uint256"
+            },
+            {
+                components: [
+                    {
+                        internalType: "enum ParamCondition",
+                        name: "condition",
+                        type: "uint8"
+                    },
+                    {
+                        name: "offset",
+                        type: "uint64"
+                    },
+
+                    {
+                        name: "param",
+                        type: "bytes32"
+                    }
+                ],
+                name: "rules",
+                type: "tuple[]"
+            }
+        ],
+        name: "permission",
+        type: "tuple[]"
+    }
+    const params = [permissionParam]
+    const values = [permission]
+
+    return encodeAbiParameters(params, values)
+}

package/policies/index.ts

@@ -0,0 +1,12 @@
+export { toGasPolicy, type GasPolicyParams } from "./toGasPolicy.js"
+export {
+    toSignatureCallerPolicy,
+    type SignatureCallerPolicyParams
+} from "./toSignatureCallerPolicy.js"
+export {
+    toRateLimitPolicy,
+    type RateLimitPolicyParams
+} from "./toRateLimitPolicy.js"
+export { toCallPolicy, type CallPolicyParams } from "./toCallPolicy.js"
+export { toPolicyId } from "./utils/toPolicyId.js"
+export { toSudoPolicy, type SudoPolicyParams } from "./toSudoPolicy.js"

package/policies/toCallPolicy.ts

@@ -0,0 +1,65 @@
+import type { Abi } from "viem"
+import { concatHex, pad } from "viem"
+import { PolicyFlags } from "../constants.js"
+import { CALL_POLICY_CONTRACT } from "../constants.js"
+import type { Policy, PolicyParams } from "../types.js"
+import {
+    encodePermissionData,
+    getPermissionFromABI
+} from "./callPolicyUtils.js"
+import { CallType, type Permission } from "./types.js"
+
+export type CallPolicyParams<
+    TAbi extends Abi | readonly unknown[],
+    TFunctionName extends string | undefined = string
+> = PolicyParams & {
+    permissions?: Permission<TAbi, TFunctionName>[]
+    type?: "call"
+}
+
+export async function toCallPolicy<
+    TAbi extends Abi | readonly unknown[],
+    TFunctionName extends string | undefined = string
+>({
+    policyAddress = CALL_POLICY_CONTRACT,
+    policyFlag = PolicyFlags.FOR_ALL_VALIDATION,
+    permissions = [],
+    type = "call"
+}: CallPolicyParams<TAbi, TFunctionName>): Promise<Policy> {
+    const generatedPermissionParams = permissions?.map((perm) =>
+        getPermissionFromABI({
+            abi: perm.abi as Abi,
+            functionName: perm.functionName as string,
+            args: perm.args as []
+        })
+    )
+
+    permissions =
+        permissions?.map((perm, index) => ({
+            ...perm,
+            callType: perm.callType ?? CallType.CALL,
+            selector:
+                perm.selector ??
+                generatedPermissionParams?.[index]?.selector ??
+                pad("0x", { size: 4 }),
+            valueLimit: perm.valueLimit ?? 0n,
+            rules: perm.rules ?? generatedPermissionParams?.[index]?.rules ?? []
+        })) ?? []
+
+    const encodedPermissionData = encodePermissionData(permissions)
+
+    return {
+        getPolicyData: () => {
+            return encodedPermissionData
+        },
+        getPolicyInfoInBytes: () => {
+            return concatHex([policyFlag, policyAddress])
+        },
+        policyParams: {
+            type,
+            policyAddress,
+            policyFlag,
+            permissions
+        } as unknown as CallPolicyParams<Abi | readonly unknown[], string>
+    }
+}

package/policies/toGasPolicy.ts

@@ -0,0 +1,44 @@
+import { type Address, concatHex, encodeAbiParameters, zeroAddress } from "viem"
+import { PolicyFlags } from "../constants.js"
+import { GAS_POLICY_CONTRACT } from "../constants.js"
+import type { Policy, PolicyParams } from "../types.js"
+
+export type GasPolicyParams = PolicyParams & {
+    allowed: bigint
+    enforcePaymaster?: boolean
+    allowedPaymaster?: Address
+    type?: "gas"
+}
+
+export async function toGasPolicy({
+    policyAddress = GAS_POLICY_CONTRACT,
+    policyFlag = PolicyFlags.FOR_ALL_VALIDATION,
+    allowed,
+    enforcePaymaster = false,
+    allowedPaymaster = zeroAddress,
+    type = "gas"
+}: GasPolicyParams): Promise<Policy> {
+    return {
+        getPolicyData: () => {
+            return encodeAbiParameters(
+                [
+                    { name: "allowed", type: "uint128" },
+                    { name: "enforcePaymaster", type: "bool" },
+                    { name: "allowedPaymaster", type: "address" }
+                ],
+                [allowed, enforcePaymaster, allowedPaymaster]
+            )
+        },
+        getPolicyInfoInBytes: () => {
+            return concatHex([policyFlag, policyAddress])
+        },
+        policyParams: {
+            type,
+            policyAddress,
+            policyFlag,
+            allowed,
+            enforcePaymaster,
+            allowedPaymaster
+        }
+    }
+}