@lit-protocol/vincent-ability-sdk 2.3.1 → 2.4.0-mma

package/dist/src/lib/gatedSigner/helpers/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/schemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;GAEG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB7B,CAAC;AAEH,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,qBAAqB,GAAI,QAAQ,aAAa,KAAG,MAAM,IAAI,mBACpD,CAAC;AACrB,eAAO,MAAM,0BAA0B,GACrC,QAAQ,aAAa,KACpB,MAAM,IAAI,wBAAmD,CAAC;AAQjE,eAAO,MAAM,kBAAkB;;;;;;EAAiB,CAAC;AACjD,eAAO,MAAM,iBAAiB;;;;;;EAAiB,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAC"}

package/dist/src/lib/gatedSigner/helpers/schemas.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSuccessSchema = exports.precheckSuccessSchema = exports.executeFailSchema = exports.precheckFailSchema = exports.isTransactionAbilityParams = exports.isUserOpAbilityParams = exports.abilityParamsSchema = void 0;
+const account_abstraction_1 = require("viem/account-abstraction");
+const zod_1 = require("zod");
+const eip712_1 = require("./eip712");
+const hex_1 = require("./hex");
+const simulation_1 = require("./simulation");
+const transaction_1 = require("./transaction");
+const userOperation_1 = require("./userOperation");
+const baseAbilityParamsSchema = zod_1.z.object({
+    alchemyRpcUrl: simulation_1.alchemyRpcUrlSchema,
+});
+/**
+ * Ability params Schemas. Can be to sign either a user operation or a transaction
+ */
+const userOpAbilityParamsSchema = baseAbilityParamsSchema.extend({
+    userOp: userOperation_1.userOpSchema.describe('User operation to simulate, validate and sign. This MUST be a valid UserOperation object as defined in the UserOperation schemas.'),
+    entryPointAddress: hex_1.addressSchema
+        .optional()
+        .default(account_abstraction_1.entryPoint07Address)
+        .describe('EntryPoint to use for the simulation. Currently only v0.7 is supported. Defaults to standard v0.7 entryPoint address.'),
+    alchemyRpcUrl: simulation_1.alchemyRpcUrlSchema,
+    validAfter: zod_1.z.number().default(0).describe('Valid after timestamp (for Safe smart accounts)'),
+    validUntil: zod_1.z.number().default(0).describe('Valid until timestamp (for Safe smart accounts)'),
+    safe4337ModuleAddress: hex_1.addressSchema
+        .default('0x75cf11467937ce3F2f357CE24ffc3DBF8fD5c226')
+        .describe('Safe 4337 Module address (for Safe smart accounts)'),
+    eip712Params: eip712_1.eip712ParamsSchema
+        .optional()
+        .describe('EIP-712 signing parameters for non-standard signing (e.g. Safe smart accounts)'),
+});
+const transactionAbilityParamsSchema = baseAbilityParamsSchema.extend({
+    alchemyRpcUrl: simulation_1.alchemyRpcUrlSchema,
+    transaction: transaction_1.transactionSchema.describe('EOA transaction to simulate, validate and sign. This must be a valid and complete transaction.'),
+});
+exports.abilityParamsSchema = zod_1.z.union([
+    userOpAbilityParamsSchema,
+    transactionAbilityParamsSchema,
+]);
+const isUserOpAbilityParams = (params) => 'userOp' in params;
+exports.isUserOpAbilityParams = isUserOpAbilityParams;
+const isTransactionAbilityParams = (params) => 'transaction' in params;
+exports.isTransactionAbilityParams = isTransactionAbilityParams;
+/**
+ * Failure result schema
+ */
+const baseFailSchema = zod_1.z.object({
+    error: zod_1.z.string().describe('A string containing the error message if the precheck failed.'),
+});
+exports.precheckFailSchema = baseFailSchema;
+exports.executeFailSchema = baseFailSchema;
+/**
+ * Success result schema
+ */
+exports.precheckSuccessSchema = zod_1.z.object({
+    simulationChanges: zod_1.z
+        .array(simulation_1.simulateAssetChangeSchema)
+        .describe('Simulated changes user op will make to the blockchain.'),
+});
+exports.executeSuccessSchema = exports.precheckSuccessSchema.extend({
+    signature: hex_1.hexSchema.describe('ECDSA signature over the received user operation or transaction.'),
+});
+//# sourceMappingURL=schemas.js.map

package/dist/src/lib/gatedSigner/helpers/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/schemas.ts"],"names":[],"mappings":";;;AAAA,kEAA+D;AAC/D,6BAAwB;AAExB,qCAA8C;AAC9C,+BAAiD;AACjD,6CAA8E;AAC9E,+CAAkD;AAClD,mDAA+C;AAE/C,MAAM,uBAAuB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,aAAa,EAAE,gCAAmB;CACnC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC;IAC/D,MAAM,EAAE,4BAAY,CAAC,QAAQ,CAC3B,mIAAmI,CACpI;IACD,iBAAiB,EAAE,mBAAa;SAC7B,QAAQ,EAAE;SACV,OAAO,CAAC,yCAAmB,CAAC;SAC5B,QAAQ,CACP,uHAAuH,CACxH;IACH,aAAa,EAAE,gCAAmB;IAClC,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,iDAAiD,CAAC;IAC7F,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,iDAAiD,CAAC;IAC7F,qBAAqB,EAAE,mBAAa;SACjC,OAAO,CAAC,4CAA4C,CAAC;SACrD,QAAQ,CAAC,oDAAoD,CAAC;IACjE,YAAY,EAAE,2BAAkB;SAC7B,QAAQ,EAAE;SACV,QAAQ,CAAC,gFAAgF,CAAC;CAC9F,CAAC,CAAC;AAEH,MAAM,8BAA8B,GAAG,uBAAuB,CAAC,MAAM,CAAC;IACpE,aAAa,EAAE,gCAAmB;IAClC,WAAW,EAAE,+BAAiB,CAAC,QAAQ,CACrC,gGAAgG,CACjG;CACF,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG,OAAC,CAAC,KAAK,CAAC;IACzC,yBAAyB;IACzB,8BAA8B;CAC/B,CAAC,CAAC;AAMI,MAAM,qBAAqB,GAAG,CAAC,MAAqB,EAAiC,EAAE,CAC5F,QAAQ,IAAI,MAAM,CAAC;AADR,QAAA,qBAAqB,yBACb;AACd,MAAM,0BAA0B,GAAG,CACxC,MAAqB,EACe,EAAE,CAAC,aAAa,IAAI,MAAM,CAAC;AAFpD,QAAA,0BAA0B,8BAE0B;AAEjE;;GAEG;AACH,MAAM,cAAc,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9B,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,+DAA+D,CAAC;CAC5F,CAAC,CAAC;AACU,QAAA,kBAAkB,GAAG,cAAc,CAAC;AACpC,QAAA,iBAAiB,GAAG,cAAc,CAAC;AAEhD;;GAEG;AACU,QAAA,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5C,iBAAiB,EAAE,OAAC;SACjB,KAAK,CAAC,sCAAyB,CAAC;SAChC,QAAQ,CAAC,wDAAwD,CAAC;CACtE,CAAC,CAAC;AACU,QAAA,oBAAoB,GAAG,6BAAqB,CAAC,MAAM,CAAC;IAC/D,SAAS,EAAE,eAAS,CAAC,QAAQ,CAAC,kEAAkE,CAAC;CAClG,CAAC,CAAC"}

package/dist/src/lib/gatedSigner/helpers/signTransaction.d.ts

@@ -0,0 +1,9 @@
+import type { Hex } from 'viem';
+import type { Transaction } from './transaction';
+interface SignTransactionParams {
+    pkpPublicKey: Hex;
+    transaction: Transaction;
+}
+export declare function signTransaction({ pkpPublicKey, transaction }: SignTransactionParams): Promise<`0x${string}`>;
+export {};
+//# sourceMappingURL=signTransaction.d.ts.map

package/dist/src/lib/gatedSigner/helpers/signTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/signTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAIhC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD,UAAU,qBAAqB;IAC7B,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,wBAAsB,eAAe,CAAC,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,qBAAqB,0BA4BzF"}

package/dist/src/lib/gatedSigner/helpers/signTransaction.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTransaction = signTransaction;
+const viem_1 = require("viem");
+const toLitActionAccount_1 = require("./toLitActionAccount");
+async function signTransaction({ pkpPublicKey, transaction }) {
+    const account = (0, toLitActionAccount_1.toLitActionAccount)(pkpPublicKey);
+    const signableTransaction = {
+        ...transaction,
+        accessList: transaction.accessList || [],
+        gas: transaction.gas ? (0, viem_1.hexToBigInt)(transaction.gas) : undefined,
+        gasLimit: transaction.gasLimit ? (0, viem_1.hexToBigInt)(transaction.gasLimit) : undefined,
+        gasPrice: transaction.gasPrice ? (0, viem_1.hexToBigInt)(transaction.gasPrice) : undefined,
+        maxFeePerGas: transaction.maxFeePerGas ? (0, viem_1.hexToBigInt)(transaction.maxFeePerGas) : undefined,
+        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas
+            ? (0, viem_1.hexToBigInt)(transaction.maxPriorityFeePerGas)
+            : undefined,
+        nonce: (0, viem_1.hexToNumber)(transaction.nonce),
+        value: (0, viem_1.hexToBigInt)(transaction.value),
+    };
+    // @ts-expect-error viem complains but the tx should be coherent besides generalities
+    const signedTx = await account.signTransaction(signableTransaction);
+    const parsed = (0, viem_1.parseTransaction)(signedTx);
+    if (!parsed.r || !parsed.s || parsed.yParity === undefined)
+        throw new Error('Signed tx missing signature fields');
+    const yParityByte = parsed.yParity === 0 ? '0x00' : '0x01';
+    const signature = (0, viem_1.concatHex)([parsed.r, parsed.s, yParityByte]);
+    return signature;
+}
+//# sourceMappingURL=signTransaction.js.map

package/dist/src/lib/gatedSigner/helpers/signTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTransaction.js","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/signTransaction.ts"],"names":[],"mappings":";;AAaA,0CA4BC;AAvCD,+BAA6E;AAI7E,6DAA0D;AAOnD,KAAK,UAAU,eAAe,CAAC,EAAE,YAAY,EAAE,WAAW,EAAyB;IACxF,MAAM,OAAO,GAAG,IAAA,uCAAkB,EAAC,YAAY,CAAC,CAAC;IAEjD,MAAM,mBAAmB,GAAG;QAC1B,GAAG,WAAW;QACd,UAAU,EAAE,WAAW,CAAC,UAAU,IAAI,EAAE;QACxC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,IAAA,kBAAW,EAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS;QAC/D,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAA,kBAAW,EAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;QAC9E,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAA,kBAAW,EAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;QAC9E,YAAY,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,IAAA,kBAAW,EAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;QAC1F,oBAAoB,EAAE,WAAW,CAAC,oBAAoB;YACpD,CAAC,CAAC,IAAA,kBAAW,EAAC,WAAW,CAAC,oBAAoB,CAAC;YAC/C,CAAC,CAAC,SAAS;QACb,KAAK,EAAE,IAAA,kBAAW,EAAC,WAAW,CAAC,KAAK,CAAC;QACrC,KAAK,EAAE,IAAA,kBAAW,EAAC,WAAW,CAAC,KAAK,CAAC;KACtC,CAAC;IAEF,qFAAqF;IACrF,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAAC;IACpE,MAAM,MAAM,GAAG,IAAA,uBAAgB,EAAC,QAAQ,CAAC,CAAC;IAC1C,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS;QACxD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IAExD,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;IAE3D,MAAM,SAAS,GAAG,IAAA,gBAAS,EAAC,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IAE/D,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/src/lib/gatedSigner/helpers/signUserOperation.d.ts

@@ -0,0 +1,15 @@
+import type { Address, Hex } from 'viem';
+import type { Eip712Params } from './eip712';
+import type { UserOp } from './userOperation';
+export interface SignUserOperationParams {
+    alchemyRpcUrl: string;
+    entryPointAddress: Address;
+    pkpPublicKey: Hex;
+    userOp: UserOp;
+    validAfter: number;
+    validUntil: number;
+    safe4337ModuleAddress: Address;
+    eip712Params?: Eip712Params;
+}
+export declare function signUserOperation({ alchemyRpcUrl, entryPointAddress, pkpPublicKey, userOp, validAfter, validUntil, safe4337ModuleAddress, eip712Params, }: SignUserOperationParams): Promise<`0x${string}`>;
+//# sourceMappingURL=signUserOperation.d.ts.map

package/dist/src/lib/gatedSigner/helpers/signUserOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signUserOperation.d.ts","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/signUserOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAMzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9C,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,GAAG,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,wBAAsB,iBAAiB,CAAC,EACtC,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,MAAM,EACN,UAAU,EACV,UAAU,EACV,qBAAqB,EACrB,YAAY,GACb,EAAE,uBAAuB,0BAiHzB"}

package/dist/src/lib/gatedSigner/helpers/signUserOperation.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signUserOperation = signUserOperation;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const toLitActionAccount_1 = require("./toLitActionAccount");
+async function signUserOperation({ alchemyRpcUrl, entryPointAddress, pkpPublicKey, userOp, validAfter, validUntil, safe4337ModuleAddress, eip712Params, }) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        transport: (0, viem_1.http)(alchemyRpcUrl),
+    });
+    const chainId = await publicClient.getChainId();
+    const account = (0, toLitActionAccount_1.toLitActionAccount)(pkpPublicKey);
+    const userOperationToHash = {
+        ...userOp,
+        callGasLimit: BigInt(userOp.callGasLimit),
+        maxFeePerGas: BigInt(userOp.maxFeePerGas),
+        maxPriorityFeePerGas: BigInt(userOp.maxPriorityFeePerGas),
+        nonce: BigInt(userOp.nonce),
+        paymasterPostOpGasLimit: BigInt(userOp.paymasterPostOpGasLimit),
+        paymasterVerificationGasLimit: BigInt(userOp.paymasterVerificationGasLimit),
+        preVerificationGas: BigInt(userOp.preVerificationGas),
+        verificationGasLimit: BigInt(userOp.verificationGasLimit),
+    };
+    if (eip712Params) {
+        const resolveValue = (value) => {
+            if (typeof value === 'string' && value.startsWith('$')) {
+                switch (value) {
+                    case '$userOp.sender':
+                        return userOperationToHash.sender;
+                    case '$userOp.nonce':
+                        return userOperationToHash.nonce;
+                    case '$userOp.initCode':
+                        if (userOperationToHash.factory && userOperationToHash.factoryData) {
+                            return (0, viem_1.concat)([userOperationToHash.factory, userOperationToHash.factoryData]);
+                        }
+                        return '0x';
+                    case '$userOp.callData':
+                        return userOperationToHash.callData;
+                    case '$userOp.callGasLimit':
+                        return userOperationToHash.callGasLimit;
+                    case '$userOp.verificationGasLimit':
+                        return userOperationToHash.verificationGasLimit;
+                    case '$userOp.preVerificationGas':
+                        return userOperationToHash.preVerificationGas;
+                    case '$userOp.maxFeePerGas':
+                        return userOperationToHash.maxFeePerGas;
+                    case '$userOp.maxPriorityFeePerGas':
+                        return userOperationToHash.maxPriorityFeePerGas;
+                    case '$userOp.paymasterAndData':
+                        if (userOperationToHash.paymaster) {
+                            return (0, viem_1.concat)([
+                                userOperationToHash.paymaster,
+                                (0, viem_1.pad)((0, viem_1.toHex)(userOperationToHash.paymasterVerificationGasLimit || 0n), { size: 16 }),
+                                (0, viem_1.pad)((0, viem_1.toHex)(userOperationToHash.paymasterPostOpGasLimit || 0n), { size: 16 }),
+                                userOperationToHash.paymasterData || '0x',
+                            ]);
+                        }
+                        return '0x';
+                    case '$userOp.signature':
+                        return userOperationToHash.signature;
+                    case '$userOp.factory':
+                        return userOperationToHash.factory;
+                    case '$userOp.factoryData':
+                        return userOperationToHash.factoryData;
+                    case '$userOp.paymaster':
+                        return userOperationToHash.paymaster;
+                    case '$userOp.paymasterData':
+                        return userOperationToHash.paymasterData;
+                    case '$userOp.paymasterVerificationGasLimit':
+                        return userOperationToHash.paymasterVerificationGasLimit;
+                    case '$userOp.paymasterPostOpGasLimit':
+                        return userOperationToHash.paymasterPostOpGasLimit;
+                    case '$entryPointAddress':
+                        return entryPointAddress;
+                    case '$validAfter':
+                        return validAfter;
+                    case '$validUntil':
+                        return validUntil;
+                    case '$safe4337ModuleAddress':
+                        return safe4337ModuleAddress;
+                    case '$chainId':
+                        return chainId;
+                    default:
+                        throw new Error(`Unknown mapping reference: ${value}`);
+                }
+            }
+            if (typeof value === 'object' && value !== null) {
+                const result = {};
+                for (const key in value) {
+                    result[key] = resolveValue(value[key]);
+                }
+                return result;
+            }
+            return value;
+        };
+        const message = resolveValue(eip712Params.message);
+        const domain = resolveValue(eip712Params.domain);
+        return await account.signTypedData({
+            domain,
+            types: eip712Params.types,
+            primaryType: eip712Params.primaryType,
+            message,
+        });
+    }
+    const userOpHash = (0, account_abstraction_1.getUserOperationHash)({
+        chainId,
+        entryPointAddress,
+        entryPointVersion: '0.7',
+        userOperation: userOperationToHash,
+    });
+    return await account.signMessage({
+        message: { raw: userOpHash },
+    });
+}
+//# sourceMappingURL=signUserOperation.js.map

package/dist/src/lib/gatedSigner/helpers/signUserOperation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signUserOperation.js","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/signUserOperation.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/gatedSigner/helpers/simulation.d.ts

@@ -0,0 +1,204 @@
+import type { Address, PublicClient } from 'viem';
+import { z } from 'zod';
+import type { Transaction } from './transaction';
+import type { UserOp } from './userOperation';
+/**
+ * Validates valid Alchemy RPC URLs, the simulation provider
+ */
+export declare const alchemyRpcUrlSchema: z.ZodString;
+export declare enum SimulateAssetType {
+    NATIVE = "NATIVE",
+    ERC20 = "ERC20",
+    ERC721 = "ERC721",
+    ERC1155 = "ERC1155",
+    /**
+     * Special contracts that don't follow ERC 721/1155. Currently limited to
+     * CryptoKitties and CryptoPunks.
+     */
+    SPECIAL_NFT = "SPECIAL_NFT"
+}
+export declare const simulateAssetTypeSchema: z.ZodNativeEnum<typeof SimulateAssetType>;
+export declare enum SimulateChangeType {
+    APPROVE = "APPROVE",
+    TRANSFER = "TRANSFER"
+}
+export declare const simulateChangeTypeSchema: z.ZodNativeEnum<typeof SimulateChangeType>;
+export declare const simulateAssetChangeSchema: z.ZodObject<{
+    assetType: z.ZodNativeEnum<typeof SimulateAssetType>;
+    changeType: z.ZodNativeEnum<typeof SimulateChangeType>;
+    from: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    to: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    rawAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    amount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contractAddress: z.ZodOptional<z.ZodNullable<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>>;
+    tokenId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    decimals: z.ZodNumber;
+    symbol: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    logo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    to: `0x${string}`;
+    from: `0x${string}`;
+    assetType: SimulateAssetType;
+    changeType: SimulateChangeType;
+    decimals: number;
+    tokenId?: string | null | undefined;
+    name?: string | null | undefined;
+    rawAmount?: string | null | undefined;
+    amount?: string | null | undefined;
+    contractAddress?: `0x${string}` | null | undefined;
+    logo?: string | null | undefined;
+}, {
+    symbol: string;
+    to: `0x${string}`;
+    from: `0x${string}`;
+    assetType: SimulateAssetType;
+    changeType: SimulateChangeType;
+    decimals: number;
+    tokenId?: string | null | undefined;
+    name?: string | null | undefined;
+    rawAmount?: string | null | undefined;
+    amount?: string | null | undefined;
+    contractAddress?: `0x${string}` | null | undefined;
+    logo?: string | null | undefined;
+}>;
+export declare const simulateAssetChangesErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    message: z.ZodString;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    message: z.ZodString;
+}, z.ZodUnknown, "strip">>;
+export declare const simulateAssetChangesResponseSchema: z.ZodObject<{
+    changes: z.ZodArray<z.ZodObject<{
+        assetType: z.ZodNativeEnum<typeof SimulateAssetType>;
+        changeType: z.ZodNativeEnum<typeof SimulateChangeType>;
+        from: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        to: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        rawAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        amount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        contractAddress: z.ZodOptional<z.ZodNullable<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>>;
+        tokenId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        decimals: z.ZodNumber;
+        symbol: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        logo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        to: `0x${string}`;
+        from: `0x${string}`;
+        assetType: SimulateAssetType;
+        changeType: SimulateChangeType;
+        decimals: number;
+        tokenId?: string | null | undefined;
+        name?: string | null | undefined;
+        rawAmount?: string | null | undefined;
+        amount?: string | null | undefined;
+        contractAddress?: `0x${string}` | null | undefined;
+        logo?: string | null | undefined;
+    }, {
+        symbol: string;
+        to: `0x${string}`;
+        from: `0x${string}`;
+        assetType: SimulateAssetType;
+        changeType: SimulateChangeType;
+        decimals: number;
+        tokenId?: string | null | undefined;
+        name?: string | null | undefined;
+        rawAmount?: string | null | undefined;
+        amount?: string | null | undefined;
+        contractAddress?: `0x${string}` | null | undefined;
+        logo?: string | null | undefined;
+    }>, "many">;
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        message: z.ZodString;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        message: z.ZodString;
+    }, z.ZodUnknown, "strip">>>>;
+}, "strip", z.ZodTypeAny, {
+    changes: {
+        symbol: string;
+        to: `0x${string}`;
+        from: `0x${string}`;
+        assetType: SimulateAssetType;
+        changeType: SimulateChangeType;
+        decimals: number;
+        tokenId?: string | null | undefined;
+        name?: string | null | undefined;
+        rawAmount?: string | null | undefined;
+        amount?: string | null | undefined;
+        contractAddress?: `0x${string}` | null | undefined;
+        logo?: string | null | undefined;
+    }[];
+    error?: z.objectOutputType<{
+        message: z.ZodString;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+}, {
+    changes: {
+        symbol: string;
+        to: `0x${string}`;
+        from: `0x${string}`;
+        assetType: SimulateAssetType;
+        changeType: SimulateChangeType;
+        decimals: number;
+        tokenId?: string | null | undefined;
+        name?: string | null | undefined;
+        rawAmount?: string | null | undefined;
+        amount?: string | null | undefined;
+        contractAddress?: `0x${string}` | null | undefined;
+        logo?: string | null | undefined;
+    }[];
+    error?: z.objectInputType<{
+        message: z.ZodString;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+}>;
+export type SimulateAssetChangesResponse = z.infer<typeof simulateAssetChangesResponseSchema>;
+export declare const simulateTransaction: ({ publicClient, transaction, }: {
+    publicClient: PublicClient;
+    transaction: Transaction;
+}) => Promise<{
+    changes: {
+        symbol: string;
+        to: `0x${string}`;
+        from: `0x${string}`;
+        assetType: SimulateAssetType;
+        changeType: SimulateChangeType;
+        decimals: number;
+        tokenId?: string | null | undefined;
+        name?: string | null | undefined;
+        rawAmount?: string | null | undefined;
+        amount?: string | null | undefined;
+        contractAddress?: `0x${string}` | null | undefined;
+        logo?: string | null | undefined;
+    }[];
+    error?: z.objectOutputType<{
+        message: z.ZodString;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+}>;
+export declare const simulateUserOp: ({ entryPointAddress, publicClient, userOp, }: {
+    entryPointAddress: Address;
+    publicClient: PublicClient;
+    userOp: UserOp;
+}) => Promise<{
+    changes: {
+        symbol: string;
+        to: `0x${string}`;
+        from: `0x${string}`;
+        assetType: SimulateAssetType;
+        changeType: SimulateChangeType;
+        decimals: number;
+        tokenId?: string | null | undefined;
+        name?: string | null | undefined;
+        rawAmount?: string | null | undefined;
+        amount?: string | null | undefined;
+        contractAddress?: `0x${string}` | null | undefined;
+        logo?: string | null | undefined;
+    }[];
+    error?: z.objectOutputType<{
+        message: z.ZodString;
+    }, z.ZodUnknown, "strip"> | null | undefined;
+}>;
+//# sourceMappingURL=simulation.d.ts.map

package/dist/src/lib/gatedSigner/helpers/simulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation.d.ts","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/simulation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9C;;GAEG;AACH,eAAO,MAAM,mBAAmB,aAM7B,CAAC;AAMJ,oBAAY,iBAAiB;IAC3B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB;;;OAGG;IACH,WAAW,gBAAgB;CAC5B;AACD,eAAO,MAAM,uBAAuB,2CAAkC,CAAC;AAEvE,oBAAY,kBAAkB;IAC5B,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AACD,eAAO,MAAM,wBAAwB,4CAAmC,CAAC;AAEzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAapC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;0BAIpB,CAAC;AAEzB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,eAAO,MAAM,mBAAmB,GAAU,gCAGvC;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,EAAE,WAAW,CAAC;CAC1B;;;;;;;;;;;;;;;;;;EAwBA,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,8CAIlC;IACD,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB;;;;;;;;;;;;;;;;;;EAOA,CAAC"}

package/dist/src/lib/gatedSigner/helpers/simulation.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateUserOp = exports.simulateTransaction = exports.simulateAssetChangesResponseSchema = exports.simulateAssetChangesErrorSchema = exports.simulateAssetChangeSchema = exports.simulateChangeTypeSchema = exports.SimulateChangeType = exports.simulateAssetTypeSchema = exports.SimulateAssetType = exports.alchemyRpcUrlSchema = void 0;
+const zod_1 = require("zod");
+const hex_1 = require("./hex");
+/**
+ * Validates valid Alchemy RPC URLs, the simulation provider
+ */
+exports.alchemyRpcUrlSchema = zod_1.z
+    .string()
+    .regex(/^https:\/\/[a-z0-9-]+\.g\.alchemy\.com\/v2\/.+/, { message: 'Invalid Alchemy RPC URL' })
+    .url()
+    .describe('Alchemy RPC URL for the desired chain. Will be used to simulate the transaction or user op and define the target chain.');
+// Types copied from @account-kit/infra
+// Zod schemas are created for runtime validation; types are derived from them to ensure consistency
+// Enums and their schemas
+var SimulateAssetType;
+(function (SimulateAssetType) {
+    SimulateAssetType["NATIVE"] = "NATIVE";
+    SimulateAssetType["ERC20"] = "ERC20";
+    SimulateAssetType["ERC721"] = "ERC721";
+    SimulateAssetType["ERC1155"] = "ERC1155";
+    /**
+     * Special contracts that don't follow ERC 721/1155. Currently limited to
+     * CryptoKitties and CryptoPunks.
+     */
+    SimulateAssetType["SPECIAL_NFT"] = "SPECIAL_NFT";
+})(SimulateAssetType || (exports.SimulateAssetType = SimulateAssetType = {}));
+exports.simulateAssetTypeSchema = zod_1.z.nativeEnum(SimulateAssetType);
+var SimulateChangeType;
+(function (SimulateChangeType) {
+    SimulateChangeType["APPROVE"] = "APPROVE";
+    SimulateChangeType["TRANSFER"] = "TRANSFER";
+})(SimulateChangeType || (exports.SimulateChangeType = SimulateChangeType = {}));
+exports.simulateChangeTypeSchema = zod_1.z.nativeEnum(SimulateChangeType);
+exports.simulateAssetChangeSchema = zod_1.z.object({
+    assetType: exports.simulateAssetTypeSchema,
+    changeType: exports.simulateChangeTypeSchema,
+    from: hex_1.hexSchema,
+    to: hex_1.hexSchema,
+    rawAmount: zod_1.z.string().nullable().optional(),
+    amount: zod_1.z.string().nullable().optional(),
+    contractAddress: hex_1.hexSchema.nullable().optional(),
+    tokenId: zod_1.z.string().nullable().optional(),
+    decimals: zod_1.z.number(),
+    symbol: zod_1.z.string(),
+    name: zod_1.z.string().nullable().optional(),
+    logo: zod_1.z.string().nullable().optional(),
+});
+exports.simulateAssetChangesErrorSchema = zod_1.z
+    .object({
+    message: zod_1.z.string(),
+})
+    .catchall(zod_1.z.unknown());
+exports.simulateAssetChangesResponseSchema = zod_1.z.object({
+    changes: zod_1.z.array(exports.simulateAssetChangeSchema),
+    error: exports.simulateAssetChangesErrorSchema.nullable().optional(),
+});
+const simulateTransaction = async ({ publicClient, transaction, }) => {
+    // Convert transaction to RPC-compatible format
+    const rpcTransaction = {
+        from: transaction.from,
+        to: transaction.to,
+        data: transaction.data,
+        value: transaction.value,
+        nonce: transaction.nonce,
+        ...(transaction.gas && { gas: transaction.gas }),
+        ...(transaction.gasLimit && !transaction.gas && { gas: transaction.gasLimit }),
+        ...(transaction.gasPrice && { gasPrice: transaction.gasPrice }),
+        ...(transaction.maxFeePerGas && { maxFeePerGas: transaction.maxFeePerGas }),
+        ...(transaction.maxPriorityFeePerGas && {
+            maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+        }),
+        ...(transaction.accessList && { accessList: transaction.accessList }),
+    };
+    return (await publicClient.request({
+        // @ts-expect-error viem types do not include this method
+        method: 'alchemy_simulateAssetChanges',
+        // @ts-expect-error viem types do not include this method
+        params: [rpcTransaction],
+    }));
+};
+exports.simulateTransaction = simulateTransaction;
+const simulateUserOp = async ({ entryPointAddress, publicClient, userOp, }) => {
+    return (await publicClient.request({
+        // @ts-expect-error viem types do not include this method
+        method: 'alchemy_simulateUserOperationAssetChanges',
+        // @ts-expect-error viem types do not include this method
+        params: [userOp, entryPointAddress],
+    }));
+};
+exports.simulateUserOp = simulateUserOp;
+//# sourceMappingURL=simulation.js.map

package/dist/src/lib/gatedSigner/helpers/simulation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation.js","sourceRoot":"","sources":["../../../../../src/lib/gatedSigner/helpers/simulation.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/gatedSigner/helpers/smartAccounts/kernel.d.ts

@@ -0,0 +1,8 @@
+import type { Hex } from 'viem';
+import type { LowLevelCall } from '../lowLevelCall';
+export declare function tryDecodeKernelCalldataToLowLevelCalls(callData: Hex): LowLevelCall[] | null;
+export declare function formatSecondaryValidatorKernelSignature(params: {
+    secondValidatorId: Hex;
+    signature: Hex;
+}): `0x${string}`;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/src/lib/gatedSigner/helpers/smartAccounts/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/gatedSigner/helpers/smartAccounts/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAO,GAAG,EAAE,MAAM,MAAM,CAAC;AAWrC,OAAO,KAAK,EAAuB,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAmJzE,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,GAAG,GAAG,YAAY,EAAE,GAAG,IAAI,CAkC3F;AAED,wBAAgB,uCAAuC,CAAC,MAAM,EAAE;IAC9D,iBAAiB,EAAE,GAAG,CAAC;IACvB,SAAS,EAAE,GAAG,CAAC;CAChB,iBAEA"}