@account-kit/smart-contracts 4.23.0 → 4.24.0

package/dist/esm/src/ma-v2/modules/single-signer-validation/signer.js

@@ -23,22 +23,26 @@ import { packUOSignature, pack1271Signature } from "../../utils.js";
  * @param {Chain} chain Chain object for the signer
  * @param {Address} accountAddress address of the smart account using this signer
  * @param {number} entityId the entity id of the signing validation
+ * @param {Hex} deferredActionData optional deferred action data to prepend to the uo signatures
  * @returns {object} an object with methods for signing operations and managing signatures
  */
-export const singleSignerMessageSigner = (signer, chain, accountAddress, entityId) => {
+export const singleSignerMessageSigner = (signer, chain, accountAddress, entityId, deferredActionData) => {
     return {
         getDummySignature: () => {
-            const dummyEcdsaSignature = "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-            return packUOSignature({
+            const sig = packUOSignature({
                 // orderedHookData: [],
-                validationSignature: dummyEcdsaSignature,
+                validationSignature: "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c",
             });
+            return deferredActionData ? concatHex([deferredActionData, sig]) : sig;
         },
-        signUserOperationHash: (uoHash) => {
-            return signer.signMessage({ raw: uoHash }).then((signature) => packUOSignature({
+        signUserOperationHash: async (uoHash) => {
+            const sig = await signer
+                .signMessage({ raw: uoHash })
+                .then((signature) => packUOSignature({
                 // orderedHookData: [],
                 validationSignature: signature,
             }));
+            return deferredActionData ? concatHex([deferredActionData, sig]) : sig;
         },
         // we apply the expected 1271 packing here since the account contract will expect it
         async signMessage({ message }) {

package/dist/esm/src/ma-v2/modules/single-signer-validation/signer.js.map

@@ -1 +1 @@
-{"version":3,"file":"signer.js","sourceRoot":"","sources":["../../../../../../src/ma-v2/modules/single-signer-validation/signer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport {\n  hashMessage,\n  hashTypedData,\n  concatHex,\n  type Hex,\n  type SignableMessage,\n  type TypedData,\n  type TypedDataDefinition,\n  type Chain,\n  type Address,\n  concat,\n} from \"viem\";\nimport {\n  getDefaultSingleSignerValidationModuleAddress,\n  SignatureType,\n} from \"../utils.js\";\n\nimport { packUOSignature, pack1271Signature } from \"../../utils.js\";\n/**\n * Creates an object with methods for generating a dummy signature, signing user operation hashes, signing messages, and signing typed data.\n *\n * @example \n \n * ```ts\n * import { singleSignerMessageSigner } from \"@account-kit/smart-contracts\";\n * import { LocalAccountSigner } from \"@aa-sdk/core\";\n *\n * const MNEMONIC = \"...\":\n * \n * const account = createModularAccountV2({ config });\n *\n * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);\n *\n * const messageSigner = singleSignerMessageSigner(signer, chain, account.address, account.signerEntity.entityId);\n * ```\n *\n * @param {SmartAccountSigner} signer Signer to use for signing operations\n * @param {Chain} chain Chain object for the signer\n * @param {Address} accountAddress address of the smart account using this signer\n * @param {number} entityId the entity id of the signing validation\n * @returns {object} an object with methods for signing operations and managing signatures\n */\nexport const singleSignerMessageSigner = (\n  signer: SmartAccountSigner,\n  chain: Chain,\n  accountAddress: Address,\n  entityId: number\n) => {\n  return {\n    getDummySignature: (): Hex => {\n      const dummyEcdsaSignature =\n        \"0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c\";\n\n      return packUOSignature({\n        // orderedHookData: [],\n        validationSignature: dummyEcdsaSignature,\n      });\n    },\n\n    signUserOperationHash: (uoHash: Hex): Promise<Hex> => {\n      return signer.signMessage({ raw: uoHash }).then((signature: Hex) =>\n        packUOSignature({\n          // orderedHookData: [],\n          validationSignature: signature,\n        })\n      );\n    },\n\n    // we apply the expected 1271 packing here since the account contract will expect it\n    async signMessage({ message }: { message: SignableMessage }): Promise<Hex> {\n      const hash = await hashMessage(message);\n\n      return pack1271Signature({\n        validationSignature: await signer.signTypedData({\n          domain: {\n            chainId: Number(chain.id),\n            verifyingContract:\n              getDefaultSingleSignerValidationModuleAddress(chain),\n            salt: concatHex([`0x${\"00\".repeat(12)}`, accountAddress]),\n          },\n          types: {\n            ReplaySafeHash: [{ name: \"hash\", type: \"bytes32\" }],\n          },\n          message: {\n            hash,\n          },\n          primaryType: \"ReplaySafeHash\",\n        }),\n        entityId,\n      });\n    },\n\n    // TODO: maybe move \"sign deferred actions\" to a separate function?\n    // we don't apply the expected 1271 packing since deferred sigs use typed data sigs and don't expect the 1271 packing\n    signTypedData: async <\n      const typedData extends TypedData | Record<string, unknown>,\n      primaryType extends keyof typedData | \"EIP712Domain\" = keyof typedData\n    >(\n      typedDataDefinition: TypedDataDefinition<typedData, primaryType>\n    ): Promise<Hex> => {\n      // the accounts domain already gives replay protection across accounts for deferred actions, so we don't need to apply another wrapping\n      const isDeferredAction =\n        typedDataDefinition?.primaryType === \"DeferredAction\" &&\n        typedDataDefinition?.domain?.verifyingContract === accountAddress;\n\n      const validationSignature = await signer.signTypedData({\n        domain: {\n          chainId: Number(chain.id),\n          verifyingContract:\n            getDefaultSingleSignerValidationModuleAddress(chain),\n          salt: concatHex([`0x${\"00\".repeat(12)}`, accountAddress]),\n        },\n        types: {\n          ReplaySafeHash: [{ name: \"hash\", type: \"bytes32\" }],\n        },\n        message: {\n          hash: hashTypedData(typedDataDefinition),\n        },\n        primaryType: \"ReplaySafeHash\",\n      });\n\n      // TODO: Handle non-EOA signer case\n      return isDeferredAction\n        ? concat([SignatureType.EOA, validationSignature])\n        : pack1271Signature({\n            validationSignature,\n            entityId,\n          });\n    },\n  };\n};\n"]}
+{"version":3,"file":"signer.js","sourceRoot":"","sources":["../../../../../../src/ma-v2/modules/single-signer-validation/signer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SmartAccountSigner } from \"@aa-sdk/core\";\nimport {\n  hashMessage,\n  hashTypedData,\n  concatHex,\n  type Hex,\n  type SignableMessage,\n  type TypedData,\n  type TypedDataDefinition,\n  type Chain,\n  type Address,\n  concat,\n} from \"viem\";\nimport {\n  getDefaultSingleSignerValidationModuleAddress,\n  SignatureType,\n} from \"../utils.js\";\n\nimport { packUOSignature, pack1271Signature } from \"../../utils.js\";\n/**\n * Creates an object with methods for generating a dummy signature, signing user operation hashes, signing messages, and signing typed data.\n *\n * @example \n \n * ```ts\n * import { singleSignerMessageSigner } from \"@account-kit/smart-contracts\";\n * import { LocalAccountSigner } from \"@aa-sdk/core\";\n *\n * const MNEMONIC = \"...\":\n * \n * const account = createModularAccountV2({ config });\n *\n * const signer = LocalAccountSigner.mnemonicToAccountSigner(MNEMONIC);\n *\n * const messageSigner = singleSignerMessageSigner(signer, chain, account.address, account.signerEntity.entityId);\n * ```\n *\n * @param {SmartAccountSigner} signer Signer to use for signing operations\n * @param {Chain} chain Chain object for the signer\n * @param {Address} accountAddress address of the smart account using this signer\n * @param {number} entityId the entity id of the signing validation\n * @param {Hex} deferredActionData optional deferred action data to prepend to the uo signatures\n * @returns {object} an object with methods for signing operations and managing signatures\n */\nexport const singleSignerMessageSigner = (\n  signer: SmartAccountSigner,\n  chain: Chain,\n  accountAddress: Address,\n  entityId: number,\n  deferredActionData?: Hex\n) => {\n  return {\n    getDummySignature: (): Hex => {\n      const sig = packUOSignature({\n        // orderedHookData: [],\n        validationSignature:\n          \"0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c\",\n      });\n\n      return deferredActionData ? concatHex([deferredActionData, sig]) : sig;\n    },\n\n    signUserOperationHash: async (uoHash: Hex): Promise<Hex> => {\n      const sig = await signer\n        .signMessage({ raw: uoHash })\n        .then((signature: Hex) =>\n          packUOSignature({\n            // orderedHookData: [],\n            validationSignature: signature,\n          })\n        );\n\n      return deferredActionData ? concatHex([deferredActionData, sig]) : sig;\n    },\n\n    // we apply the expected 1271 packing here since the account contract will expect it\n    async signMessage({ message }: { message: SignableMessage }): Promise<Hex> {\n      const hash = await hashMessage(message);\n\n      return pack1271Signature({\n        validationSignature: await signer.signTypedData({\n          domain: {\n            chainId: Number(chain.id),\n            verifyingContract:\n              getDefaultSingleSignerValidationModuleAddress(chain),\n            salt: concatHex([`0x${\"00\".repeat(12)}`, accountAddress]),\n          },\n          types: {\n            ReplaySafeHash: [{ name: \"hash\", type: \"bytes32\" }],\n          },\n          message: {\n            hash,\n          },\n          primaryType: \"ReplaySafeHash\",\n        }),\n        entityId,\n      });\n    },\n\n    // TODO: maybe move \"sign deferred actions\" to a separate function?\n    // we don't apply the expected 1271 packing since deferred sigs use typed data sigs and don't expect the 1271 packing\n    signTypedData: async <\n      const typedData extends TypedData | Record<string, unknown>,\n      primaryType extends keyof typedData | \"EIP712Domain\" = keyof typedData\n    >(\n      typedDataDefinition: TypedDataDefinition<typedData, primaryType>\n    ): Promise<Hex> => {\n      // the accounts domain already gives replay protection across accounts for deferred actions, so we don't need to apply another wrapping\n      const isDeferredAction =\n        typedDataDefinition?.primaryType === \"DeferredAction\" &&\n        typedDataDefinition?.domain?.verifyingContract === accountAddress;\n\n      const validationSignature = await signer.signTypedData({\n        domain: {\n          chainId: Number(chain.id),\n          verifyingContract:\n            getDefaultSingleSignerValidationModuleAddress(chain),\n          salt: concatHex([`0x${\"00\".repeat(12)}`, accountAddress]),\n        },\n        types: {\n          ReplaySafeHash: [{ name: \"hash\", type: \"bytes32\" }],\n        },\n        message: {\n          hash: hashTypedData(typedDataDefinition),\n        },\n        primaryType: \"ReplaySafeHash\",\n      });\n\n      // TODO: Handle non-EOA signer case\n      return isDeferredAction\n        ? concat([SignatureType.EOA, validationSignature])\n        : pack1271Signature({\n            validationSignature,\n            entityId,\n          });\n    },\n  };\n};\n"]}

package/dist/esm/src/ma-v2/permissionBuilder.d.ts

@@ -0,0 +1,115 @@
+import { type Address, type Hex } from "viem";
+import { type HookConfig } from "./actions/common/types.js";
+import { type InstallValidationParams } from "./actions/install-validation/installValidation.js";
+import type { ModularAccountV2Client } from "./client/client.js";
+import { type DeferredActionTypedData } from "./actions/deferralActions.js";
+export declare enum PermissionType {
+    NATIVE_TOKEN_TRANSFER = "native-token-transfer",
+    ERC20_TOKEN_TRANSFER = "erc20-token-transfer",
+    GAS_LIMIT = "gas-limit",
+    CONTRACT_ACCESS = "contract-access",
+    ACCOUNT_FUNCTIONS = "account-functions",
+    FUNCTIONS_ON_ALL_CONTRACTS = "functions-on-all-contracts",
+    FUNCTIONS_ON_CONTRACT = "functions-on-contract",
+    ROOT = "root"
+}
+type OneOf<T extends {}[]> = T[number];
+type Key = {
+    publicKey: Hex;
+    type: "secp256k1" | "contract";
+};
+export type Permission = OneOf<[
+    {
+        type: PermissionType.NATIVE_TOKEN_TRANSFER;
+        data: {
+            allowance: Hex;
+        };
+    },
+    {
+        type: PermissionType.ERC20_TOKEN_TRANSFER;
+        data: {
+            address: Address;
+            allowance: Hex;
+        };
+    },
+    {
+        type: PermissionType.GAS_LIMIT;
+        data: {
+            limit: Hex;
+        };
+    },
+    {
+        type: PermissionType.CONTRACT_ACCESS;
+        data: {
+            address: Address;
+        };
+    },
+    {
+        type: PermissionType.ACCOUNT_FUNCTIONS;
+        data: {
+            functions: Hex[];
+        };
+    },
+    {
+        type: PermissionType.FUNCTIONS_ON_ALL_CONTRACTS;
+        data: {
+            functions: Hex[];
+        };
+    },
+    {
+        type: PermissionType.FUNCTIONS_ON_CONTRACT;
+        data: {
+            address: Address;
+            functions: Hex[];
+        };
+    },
+    {
+        type: PermissionType.ROOT;
+        data?: never;
+    }
+]>;
+type Hook = {
+    hookConfig: HookConfig;
+    initData: Hex;
+};
+export declare class PermissionBuilder {
+    private client;
+    private validationConfig;
+    private selectors;
+    private installData;
+    private permissions;
+    private hooks;
+    private nonce;
+    private hasAssociatedExecHooks;
+    constructor(client: ModularAccountV2Client);
+    configure({ key, entityId, nonce, selectors, hooks, }: {
+        key: Key;
+        entityId: number;
+        nonce: bigint;
+        selectors?: Hex[];
+        hooks?: Hook[];
+    }): this;
+    addSelector({ selector }: {
+        selector: Hex;
+    }): this;
+    addPermission({ permission }: {
+        permission: Permission;
+    }): this;
+    addPermissions({ permissions }: {
+        permissions: Permission[];
+    }): this;
+    compileDeferred({ deadline, }: {
+        deadline: number;
+        uoValidationEntityId: number;
+        uoIsGlobalValidation: boolean;
+    }): Promise<{
+        typedData: DeferredActionTypedData;
+        fullPreSignatureDeferredActionDigest: Hex;
+    }>;
+    compileRaw(): Promise<Hex>;
+    compileInstallArgs(): Promise<InstallValidationParams>;
+    private validateConfiguration;
+    private translatePermissions;
+    private addHooks;
+}
+export {};

package/dist/esm/src/ma-v2/permissionBuilder.js

@@ -0,0 +1,485 @@
+import { toHex, zeroAddress } from "viem";
+import { HookType, } from "./actions/common/types.js";
+import { installValidationActions, } from "./actions/install-validation/installValidation.js";
+import { deferralActions, } from "./actions/deferralActions.js";
+import { NativeTokenLimitModule } from "./modules/native-token-limit-module/module.js";
+import { getDefaultAllowlistModuleAddress, getDefaultNativeTokenLimitModuleAddress, getDefaultSingleSignerValidationModuleAddress, getDefaultTimeRangeModuleAddress, } from "./modules/utils.js";
+import { SingleSignerValidationModule } from "./modules/single-signer-validation/module.js";
+import { AllowlistModule } from "./modules/allowlist-module/module.js";
+import { TimeRangeModule } from "./modules/time-range-module/module.js";
+// We use this to offset the ERC20 spend limit entityId
+const HALF_UINT32 = 2147483647;
+const ERC20_APPROVE_SELECTOR = "0x095ea7b3";
+const ERC20_TRANSFER_SELECTOR = "0xa9059cbb";
+const ACCOUNT_EXECUTE_SELECTOR = "0xb61d27f6";
+const ACCOUNT_EXECUTEBATCH_SELECTOR = "0x34fcd5be";
+export var PermissionType;
+(function (PermissionType) {
+    PermissionType["NATIVE_TOKEN_TRANSFER"] = "native-token-transfer";
+    PermissionType["ERC20_TOKEN_TRANSFER"] = "erc20-token-transfer";
+    // ERC721_TOKEN_TRANSFER = "erc721-token-transfer", //Unimplemented
+    // ERC1155_TOKEN_TRANSFER = "erc1155-token-transfer", //Unimplemented
+    PermissionType["GAS_LIMIT"] = "gas-limit";
+    // CALL_LIMIT = "call-limit", //Unimplemented
+    // RATE_LIMIT = "rate-limit", //Unimplemented
+    PermissionType["CONTRACT_ACCESS"] = "contract-access";
+    PermissionType["ACCOUNT_FUNCTIONS"] = "account-functions";
+    PermissionType["FUNCTIONS_ON_ALL_CONTRACTS"] = "functions-on-all-contracts";
+    PermissionType["FUNCTIONS_ON_CONTRACT"] = "functions-on-contract";
+    PermissionType["ROOT"] = "root";
+})(PermissionType || (PermissionType = {}));
+var HookIdentifier;
+(function (HookIdentifier) {
+    HookIdentifier[HookIdentifier["NATIVE_TOKEN_TRANSFER"] = 0] = "NATIVE_TOKEN_TRANSFER";
+    HookIdentifier[HookIdentifier["ERC20_TOKEN_TRANSFER"] = 1] = "ERC20_TOKEN_TRANSFER";
+    HookIdentifier[HookIdentifier["GAS_LIMIT"] = 2] = "GAS_LIMIT";
+    HookIdentifier[HookIdentifier["PREVAL_ALLOWLIST"] = 3] = "PREVAL_ALLOWLIST";
+})(HookIdentifier || (HookIdentifier = {}));
+export class PermissionBuilder {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "validationConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                moduleAddress: zeroAddress,
+                entityId: 0, // uint32
+                isGlobal: false,
+                isSignatureValidation: false,
+                isUserOpValidation: false,
+            }
+        });
+        Object.defineProperty(this, "selectors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "installData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "0x"
+        });
+        Object.defineProperty(this, "permissions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "hooks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "nonce", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0n
+        });
+        Object.defineProperty(this, "hasAssociatedExecHooks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.client = client;
+    }
+    // Configures the builder
+    configure({ key, entityId, nonce, selectors, hooks, }) {
+        this.validationConfig = {
+            moduleAddress: getDefaultSingleSignerValidationModuleAddress(this.client.chain),
+            entityId,
+            isUserOpValidation: true,
+            isGlobal: false,
+            isSignatureValidation: false,
+        };
+        this.installData = SingleSignerValidationModule.encodeOnInstallData({
+            entityId: entityId,
+            signer: key.publicKey,
+        });
+        if (selectors)
+            this.selectors = selectors;
+        if (hooks)
+            this.hooks = hooks;
+        this.nonce = nonce;
+        return this;
+    }
+    addSelector({ selector }) {
+        this.selectors.push(selector);
+        return this;
+    }
+    addPermission({ permission }) {
+        // Check 1: If we're adding root, we can't have any other permissions
+        if (permission.type === PermissionType.ROOT) {
+            if (this.permissions.length !== 0) {
+                throw new Error("PERMISSION: ROOT: Cannot add ROOT permission with other permissions");
+            }
+            this.permissions.push(permission);
+            // Set isGlobal to true
+            this.validationConfig.isGlobal = true;
+            return this;
+        }
+        // Check 2: If the permission is NOT ROOT (guaranteed), ensure there is no ROOT permission set
+        // Will resolve to undefined if ROOT is not found
+        // NOTE: Technically this could be replaced by checking permissions[0] since it should not be possible
+        // to have >1 permission with root among them
+        if (this.permissions.find((p) => p.type === PermissionType.ROOT)) {
+            throw new Error(`PERMISSION: ${permission.type} => Cannot add permissions with ROOT enabled`);
+        }
+        // Check 3: If the permission is either CONTRACT_ACCESS or FUNCTIONS_ON_CONTRACT, ensure it doesn't collide with another like it.
+        if (permission.type === PermissionType.CONTRACT_ACCESS ||
+            permission.type === PermissionType.FUNCTIONS_ON_CONTRACT) {
+            // Check 3.1: address must not be the account address, or the user should use the ACCOUNT_FUNCTIONS permission
+            if (permission.data.address === this.client.account.address) {
+                throw new Error(`PERMISSION: ${permission.type} => Account address as target, use ACCOUNT_FUNCTIONS for account address`);
+            }
+            // Check 3.2: there must not be an existing permission with this address as a target
+            const targetAddress = permission.data.address;
+            const existingPermissionWithSameAddress = this.permissions.find((p) => (p.type === PermissionType.CONTRACT_ACCESS &&
+                "address" in p.data &&
+                p.data.address === targetAddress) ||
+                (p.type === PermissionType.FUNCTIONS_ON_CONTRACT &&
+                    "address" in p.data &&
+                    p.data.address === targetAddress));
+            if (existingPermissionWithSameAddress) {
+                throw new Error(`PERMISSION: ${permission.type} => Address ${targetAddress} already has a permission. Cannot add multiple CONTRACT_ACCESS or FUNCTIONS_ON_CONTRACT permissions for the same target address.`);
+            }
+        }
+        // Check 4: If the permission is ACCOUNT_FUNCTIONS, add selectors
+        if (permission.type === PermissionType.ACCOUNT_FUNCTIONS) {
+            this.selectors = [...this.selectors, ...permission.data.functions];
+            return this;
+        }
+        this.permissions.push(permission);
+        return this;
+    }
+    addPermissions({ permissions }) {
+        // We could validate each permission here, but for simplicity we'll just add them
+        // A better approach would be to call addPermission for each one
+        permissions.forEach((permission) => {
+            this.addPermission({ permission });
+        });
+        return this;
+    }
+    // Use for building deferred action typed data to sign
+    async compileDeferred({ deadline, }) {
+        // Need to remove this because compileRaw may add selectors
+        // this.validateConfiguration();
+        // Add time range module hook via expiry
+        if (deadline !== 0) {
+            if (deadline < Date.now() / 1000) {
+                throw new Error(`PERMISSION: compileDeferred(): Deadline ${deadline} cannot be before now (${Date.now() / 1000})`);
+            }
+            this.hooks.push(TimeRangeModule.buildHook({
+                entityId: this.validationConfig.entityId, // will be timerange entityId
+                validUntil: deadline,
+                validAfter: 0,
+            }, getDefaultTimeRangeModuleAddress(this.client.chain)));
+        }
+        const installValidationCall = await this.compileRaw();
+        const { typedData } = await deferralActions(this.client).createDeferredActionTypedDataObject({
+            callData: installValidationCall,
+            deadline: deadline,
+            nonce: this.nonce,
+        });
+        const preSignatureDigest = deferralActions(this.client).buildPreSignatureDeferredActionDigest({ typedData });
+        // Encode additional information to build the full pre-signature digest
+        const fullPreSignatureDeferredActionDigest = `0x00${this.hasAssociatedExecHooks ? "01" : "00"}${toHex(this.nonce, {
+            size: 32,
+        }).slice(2)}${preSignatureDigest.slice(2)}`;
+        return {
+            typedData,
+            fullPreSignatureDeferredActionDigest,
+        };
+    }
+    // Use for direct `installValidation()` low-level calls (maybe useless)
+    async compileRaw() {
+        // Translate all permissions into raw hooks if >0
+        if (this.permissions.length > 0) {
+            const rawHooks = this.translatePermissions(this.validationConfig.entityId);
+            // Add the translated permissions as hooks
+            this.addHooks(rawHooks);
+        }
+        this.validateConfiguration();
+        return await installValidationActions(this.client).encodeInstallValidation({
+            validationConfig: this.validationConfig,
+            selectors: this.selectors,
+            installData: this.installData,
+            hooks: this.hooks,
+            account: this.client.account,
+        });
+    }
+    // Use for compiling args to installValidation
+    async compileInstallArgs() {
+        this.validateConfiguration();
+        return {
+            validationConfig: this.validationConfig,
+            selectors: this.selectors,
+            installData: this.installData,
+            hooks: this.hooks,
+            account: this.client.account,
+        };
+    }
+    validateConfiguration() {
+        if (this.validationConfig.isGlobal === false &&
+            this.selectors.length === 0) {
+            throw new Error("Validation config unset, use permissionBuilder.configure(...)");
+        }
+    }
+    // Used to translate consolidated permissions into raw unencoded hooks
+    // Note entityId will be a member object later
+    translatePermissions(entityId) {
+        const rawHooks = {
+            [HookIdentifier.NATIVE_TOKEN_TRANSFER]: undefined,
+            [HookIdentifier.ERC20_TOKEN_TRANSFER]: undefined,
+            [HookIdentifier.GAS_LIMIT]: undefined,
+            [HookIdentifier.PREVAL_ALLOWLIST]: undefined,
+        };
+        this.permissions.forEach((permission) => {
+            switch (permission.type) {
+                case PermissionType.NATIVE_TOKEN_TRANSFER:
+                    // Should never be added twice, check is on addPermission(s) too
+                    if (rawHooks[HookIdentifier.NATIVE_TOKEN_TRANSFER] !== undefined) {
+                        throw new Error("PERMISSION: NATIVE_TOKEN_TRANSFER => Must have at most ONE native token transfer permission");
+                    }
+                    rawHooks[HookIdentifier.NATIVE_TOKEN_TRANSFER] = {
+                        hookConfig: {
+                            address: getDefaultNativeTokenLimitModuleAddress(this.client.chain),
+                            entityId,
+                            hookType: HookType.EXECUTION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId,
+                            spendLimit: BigInt(permission.data.allowance),
+                        },
+                    };
+                    this.hasAssociatedExecHooks = true;
+                    break;
+                case PermissionType.ERC20_TOKEN_TRANSFER:
+                    if (permission.data.address === zeroAddress) {
+                        throw new Error("PERMISSION: ERC20_TOKEN_TRANSFER => Zero address provided");
+                    }
+                    rawHooks[HookIdentifier.ERC20_TOKEN_TRANSFER] = {
+                        hookConfig: {
+                            address: getDefaultAllowlistModuleAddress(this.client.chain),
+                            entityId: entityId + HALF_UINT32,
+                            hookType: HookType.EXECUTION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId: entityId + HALF_UINT32,
+                            inputs: [
+                                // Add previous inputs if they exist
+                                ...(rawHooks[HookIdentifier.ERC20_TOKEN_TRANSFER]?.initData
+                                    .inputs || []),
+                                {
+                                    target: permission.data.address,
+                                    hasSelectorAllowlist: false,
+                                    hasERC20SpendLimit: true,
+                                    erc20SpendLimit: BigInt(permission.data.allowance),
+                                    selectors: [],
+                                },
+                            ],
+                        },
+                    };
+                    this.hasAssociatedExecHooks = true;
+                    // Also allow `approve` and `transfer` for the erc20
+                    rawHooks[HookIdentifier.PREVAL_ALLOWLIST] = {
+                        hookConfig: {
+                            address: getDefaultAllowlistModuleAddress(this.client.chain),
+                            entityId,
+                            hookType: HookType.VALIDATION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId,
+                            inputs: [
+                                // Add previous inputs if they exist
+                                ...(rawHooks[HookIdentifier.PREVAL_ALLOWLIST]?.initData
+                                    .inputs || []),
+                                {
+                                    target: permission.data.address,
+                                    hasSelectorAllowlist: true,
+                                    hasERC20SpendLimit: false,
+                                    erc20SpendLimit: 0n,
+                                    selectors: [ERC20_APPROVE_SELECTOR, ERC20_TRANSFER_SELECTOR], // approve, transfer
+                                },
+                            ],
+                        },
+                    };
+                    break;
+                case PermissionType.GAS_LIMIT:
+                    // Should only ever be added once, check is also on addPermission(s)
+                    if (rawHooks[HookIdentifier.GAS_LIMIT] !== undefined) {
+                        throw new Error("PERMISSION: GAS_LIMIT => Must have at most ONE gas limit permission");
+                    }
+                    rawHooks[HookIdentifier.GAS_LIMIT] = {
+                        hookConfig: {
+                            address: getDefaultNativeTokenLimitModuleAddress(this.client.chain),
+                            entityId,
+                            hookType: HookType.VALIDATION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId,
+                            spendLimit: BigInt(permission.data.limit),
+                        },
+                    };
+                    break;
+                case PermissionType.CONTRACT_ACCESS:
+                    if (permission.data.address === zeroAddress) {
+                        throw new Error("PERMISSION: CONTRACT_ACCESS => Zero address provided");
+                    }
+                    rawHooks[HookIdentifier.PREVAL_ALLOWLIST] = {
+                        hookConfig: {
+                            address: getDefaultAllowlistModuleAddress(this.client.chain),
+                            entityId,
+                            hookType: HookType.VALIDATION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId,
+                            inputs: [
+                                // Add previous inputs if they exist
+                                ...(rawHooks[HookIdentifier.PREVAL_ALLOWLIST]?.initData
+                                    .inputs || []),
+                                {
+                                    target: permission.data.address,
+                                    hasSelectorAllowlist: false,
+                                    hasERC20SpendLimit: false,
+                                    erc20SpendLimit: 0n,
+                                    selectors: [],
+                                },
+                            ],
+                        },
+                    };
+                    break;
+                case PermissionType.ACCOUNT_FUNCTIONS:
+                    if (permission.data.functions.length === 0) {
+                        throw new Error("PERMISSION: ACCOUNT_FUNCTION => No functions provided"); // should be in add perm
+                    }
+                    break;
+                case PermissionType.FUNCTIONS_ON_ALL_CONTRACTS:
+                    if (permission.data.functions.length === 0) {
+                        throw new Error("PERMISSION: FUNCTIONS_ON_ALL_CONTRACTS => No functions provided");
+                    }
+                    rawHooks[HookIdentifier.PREVAL_ALLOWLIST] = {
+                        hookConfig: {
+                            address: getDefaultAllowlistModuleAddress(this.client.chain),
+                            entityId,
+                            hookType: HookType.VALIDATION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId,
+                            inputs: [
+                                // Add previous inputs if they exist
+                                ...(rawHooks[HookIdentifier.PREVAL_ALLOWLIST]?.initData
+                                    .inputs || []),
+                                {
+                                    target: zeroAddress,
+                                    hasSelectorAllowlist: false,
+                                    hasERC20SpendLimit: false,
+                                    erc20SpendLimit: 0n,
+                                    selectors: permission.data.functions,
+                                },
+                            ],
+                        },
+                    };
+                    break;
+                case PermissionType.FUNCTIONS_ON_CONTRACT:
+                    if (permission.data.functions.length === 0) {
+                        throw new Error("PERMISSION: FUNCTIONS_ON_CONTRACT => No functions provided");
+                    }
+                    if (permission.data.address === zeroAddress) {
+                        throw new Error("PERMISSION: FUNCTIONS_ON_CONTRACT => Zero address provided");
+                    }
+                    rawHooks[HookIdentifier.PREVAL_ALLOWLIST] = {
+                        hookConfig: {
+                            address: getDefaultAllowlistModuleAddress(this.client.chain),
+                            entityId,
+                            hookType: HookType.VALIDATION,
+                            hasPreHooks: true,
+                            hasPostHooks: false,
+                        },
+                        initData: {
+                            entityId,
+                            inputs: [
+                                // Add previous inputs if they exist
+                                ...(rawHooks[HookIdentifier.PREVAL_ALLOWLIST]?.initData
+                                    .inputs || []),
+                                {
+                                    target: permission.data.address,
+                                    hasSelectorAllowlist: true,
+                                    hasERC20SpendLimit: false,
+                                    erc20SpendLimit: 0n,
+                                    selectors: permission.data.functions,
+                                },
+                            ],
+                        },
+                    };
+                    break;
+                case PermissionType.ROOT:
+                    // Root permission handled in addPermission
+                    break;
+                default:
+                    throw new Error(`Unsupported permission type: ${permission.type}`);
+            }
+            // isGlobal guaranteed to be false since it's only set with root permissions,
+            // we must add access to execute & executeBatch if there's a preVal allowlist hook set.
+            if (rawHooks[HookIdentifier.PREVAL_ALLOWLIST] !== undefined) {
+                const selectorsToAdd = [
+                    ACCOUNT_EXECUTE_SELECTOR,
+                    ACCOUNT_EXECUTEBATCH_SELECTOR,
+                ]; // execute, executeBatch
+                // Only add the selectors if they aren't already in this.selectors
+                const newSelectors = selectorsToAdd.filter((selector) => !this.selectors.includes(selector));
+                this.selectors = [...this.selectors, ...newSelectors];
+            }
+        });
+        return rawHooks;
+    }
+    addHooks(rawHooks) {
+        if (rawHooks[HookIdentifier.NATIVE_TOKEN_TRANSFER]) {
+            this.hooks.push({
+                hookConfig: rawHooks[HookIdentifier.NATIVE_TOKEN_TRANSFER].hookConfig,
+                initData: NativeTokenLimitModule.encodeOnInstallData(rawHooks[HookIdentifier.NATIVE_TOKEN_TRANSFER].initData),
+            });
+        }
+        if (rawHooks[HookIdentifier.ERC20_TOKEN_TRANSFER]) {
+            this.hooks.push({
+                hookConfig: rawHooks[HookIdentifier.ERC20_TOKEN_TRANSFER].hookConfig,
+                initData: AllowlistModule.encodeOnInstallData(rawHooks[HookIdentifier.ERC20_TOKEN_TRANSFER].initData),
+            });
+        }
+        if (rawHooks[HookIdentifier.GAS_LIMIT]) {
+            this.hooks.push({
+                hookConfig: rawHooks[HookIdentifier.GAS_LIMIT].hookConfig,
+                initData: NativeTokenLimitModule.encodeOnInstallData(rawHooks[HookIdentifier.GAS_LIMIT].initData),
+            });
+        }
+        if (rawHooks[HookIdentifier.PREVAL_ALLOWLIST]) {
+            this.hooks.push({
+                hookConfig: rawHooks[HookIdentifier.PREVAL_ALLOWLIST].hookConfig,
+                initData: AllowlistModule.encodeOnInstallData(rawHooks[HookIdentifier.PREVAL_ALLOWLIST].initData),
+            });
+        }
+    }
+}
+//# sourceMappingURL=permissionBuilder.js.map