@crossmint/client-sdk-smart-wallet 0.1.21 → 0.1.22

package/dist/chunk-PVFA6PBX.cjs

@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/blockchain/chains.ts
+
+
+
+
+
+
+
+
+
+var _chains = require('viem/chains');
+var _commonsdkbase = require('@crossmint/common-sdk-base');
+var SmartWalletTestnet = {
+  BASE_SEPOLIA: _commonsdkbase.BlockchainIncludingTestnet.BASE_SEPOLIA,
+  POLYGON_AMOY: _commonsdkbase.BlockchainIncludingTestnet.POLYGON_AMOY,
+  OPTIMISM_SEPOLIA: _commonsdkbase.BlockchainIncludingTestnet.OPTIMISM_SEPOLIA,
+  ARBITRUM_SEPOLIA: _commonsdkbase.BlockchainIncludingTestnet.ARBITRUM_SEPOLIA
+};
+var SMART_WALLET_TESTNETS = _commonsdkbase.objectValues.call(void 0, SmartWalletTestnet);
+var SmartWalletMainnet = {
+  BASE: _commonsdkbase.BlockchainIncludingTestnet.BASE,
+  POLYGON: _commonsdkbase.BlockchainIncludingTestnet.POLYGON,
+  OPTIMISM: _commonsdkbase.BlockchainIncludingTestnet.OPTIMISM,
+  ARBITRUM: _commonsdkbase.BlockchainIncludingTestnet.ARBITRUM
+};
+var SMART_WALLET_MAINNETS = _commonsdkbase.objectValues.call(void 0, SmartWalletMainnet);
+var SmartWalletChain = {
+  ...SmartWalletTestnet,
+  ...SmartWalletMainnet
+};
+var SMART_WALLET_CHAINS = _commonsdkbase.objectValues.call(void 0, SmartWalletChain);
+function isTestnetChain(chain) {
+  return SMART_WALLET_TESTNETS.includes(chain);
+}
+function isMainnetChain(chain) {
+  return SMART_WALLET_MAINNETS.includes(chain);
+}
+var viemNetworks = {
+  polygon: _chains.polygon,
+  "polygon-amoy": _chains.polygonAmoy,
+  base: _chains.base,
+  "base-sepolia": _chains.baseSepolia,
+  optimism: _chains.optimism,
+  "optimism-sepolia": _chains.optimismSepolia,
+  arbitrum: _chains.arbitrum,
+  "arbitrum-sepolia": _chains.arbitrumSepolia
+};
+
+
+
+
+
+
+
+
+
+
+
+exports.SmartWalletTestnet = SmartWalletTestnet; exports.SMART_WALLET_TESTNETS = SMART_WALLET_TESTNETS; exports.SmartWalletMainnet = SmartWalletMainnet; exports.SMART_WALLET_MAINNETS = SMART_WALLET_MAINNETS; exports.SmartWalletChain = SmartWalletChain; exports.SMART_WALLET_CHAINS = SMART_WALLET_CHAINS; exports.isTestnetChain = isTestnetChain; exports.isMainnetChain = isMainnetChain; exports.viemNetworks = viemNetworks;
+//# sourceMappingURL=chunk-PVFA6PBX.cjs.map

package/dist/chunk-PVFA6PBX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/chains.ts"],"names":[],"mappings":";AAAA;AAAA,EAEI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AAEP,SAAS,8BAA8B,YAA+B,oBAAoB;AAEnF,IAAM,qBAAqB;AAAA,EAC9B,cAAc,WAAW;AAAA,EACzB,cAAc,WAAW;AAAA,EACzB,kBAAkB,WAAW;AAAA,EAC7B,kBAAkB,WAAW;AACjC;AAEO,IAAM,wBAAwB,aAAa,kBAAkB;AAE7D,IAAM,qBAAqB;AAAA,EAC9B,MAAM,WAAW;AAAA,EACjB,SAAS,WAAW;AAAA,EACpB,UAAU,WAAW;AAAA,EACrB,UAAU,WAAW;AACzB;AAEO,IAAM,wBAAwB,aAAa,kBAAkB;AAE7D,IAAM,mBAAmB;AAAA,EAC5B,GAAG;AAAA,EACH,GAAG;AACP;AAEO,IAAM,sBAAsB,aAAa,gBAAgB;AAEzD,SAAS,eAAe,OAAsD;AACjF,SAAQ,sBAA8B,SAAS,KAAK;AACxD;AAEO,SAAS,eAAe,OAAsD;AACjF,SAAQ,sBAA8B,SAAS,KAAK;AACxD;AAEO,IAAM,eAAgD;AAAA,EACzD;AAAA,EACA,gBAAgB;AAAA,EAChB;AAAA,EACA,gBAAgB;AAAA,EAChB;AAAA,EACA,oBAAoB;AAAA,EACpB;AAAA,EACA,oBAAoB;AACxB","sourcesContent":["import {\n    type Chain,\n    arbitrum,\n    arbitrumSepolia,\n    base,\n    baseSepolia,\n    optimism,\n    optimismSepolia,\n    polygon,\n    polygonAmoy,\n} from \"viem/chains\";\n\nimport { BlockchainIncludingTestnet as Blockchain, type ObjectValues, objectValues } from \"@crossmint/common-sdk-base\";\n\nexport const SmartWalletTestnet = {\n    BASE_SEPOLIA: Blockchain.BASE_SEPOLIA,\n    POLYGON_AMOY: Blockchain.POLYGON_AMOY,\n    OPTIMISM_SEPOLIA: Blockchain.OPTIMISM_SEPOLIA,\n    ARBITRUM_SEPOLIA: Blockchain.ARBITRUM_SEPOLIA,\n} as const;\nexport type SmartWalletTestnet = ObjectValues<typeof SmartWalletTestnet>;\nexport const SMART_WALLET_TESTNETS = objectValues(SmartWalletTestnet);\n\nexport const SmartWalletMainnet = {\n    BASE: Blockchain.BASE,\n    POLYGON: Blockchain.POLYGON,\n    OPTIMISM: Blockchain.OPTIMISM,\n    ARBITRUM: Blockchain.ARBITRUM,\n} as const;\nexport type SmartWalletMainnet = ObjectValues<typeof SmartWalletMainnet>;\nexport const SMART_WALLET_MAINNETS = objectValues(SmartWalletMainnet);\n\nexport const SmartWalletChain = {\n    ...SmartWalletTestnet,\n    ...SmartWalletMainnet,\n} as const;\nexport type SmartWalletChain = ObjectValues<typeof SmartWalletChain>;\nexport const SMART_WALLET_CHAINS = objectValues(SmartWalletChain);\n\nexport function isTestnetChain(chain: SmartWalletChain): chain is SmartWalletTestnet {\n    return (SMART_WALLET_TESTNETS as any).includes(chain);\n}\n\nexport function isMainnetChain(chain: SmartWalletChain): chain is SmartWalletMainnet {\n    return (SMART_WALLET_MAINNETS as any).includes(chain);\n}\n\nexport const viemNetworks: Record<SmartWalletChain, Chain> = {\n    polygon: polygon,\n    \"polygon-amoy\": polygonAmoy,\n    base: base,\n    \"base-sepolia\": baseSepolia,\n    optimism: optimism,\n    \"optimism-sepolia\": optimismSepolia,\n    arbitrum: arbitrum,\n    \"arbitrum-sepolia\": arbitrumSepolia,\n};\n"]}

package/dist/chunk-QFMVSQA5.js

@@ -0,0 +1,93 @@
+import {
+  usesGelatoBundler
+} from "./chunk-JOB7STIS.js";
+import {
+  scwLogger
+} from "./chunk-MILDB23W.js";
+import {
+  SmartWalletError
+} from "./chunk-ASIPMVRQ.js";
+
+// src/blockchain/wallets/clientDecorator.ts
+import { stringify } from "viem";
+var transactionMethods = [
+  "sendTransaction",
+  "writeContract",
+  "sendUserOperation"
+];
+var signingMethods = [
+  "signMessage",
+  "signTypedData"
+];
+function isTxnMethod(method) {
+  return transactionMethods.includes(method);
+}
+function isSignMethod(method) {
+  return signingMethods.includes(method);
+}
+var ClientDecorator = class {
+  constructor(errorProcessor, logger = scwLogger) {
+    this.errorProcessor = errorProcessor;
+    this.logger = logger;
+  }
+  decorate({
+    crossmintChain,
+    smartAccountClient
+  }) {
+    return new Proxy(smartAccountClient, {
+      get: (target, prop, receiver) => {
+        const originalMethod = Reflect.get(target, prop, receiver);
+        if (typeof originalMethod !== "function" || typeof prop !== "string" || !(isSignMethod(prop) || isTxnMethod(prop))) {
+          return originalMethod;
+        }
+        return (...args) => this.logger.logPerformance(
+          `CrossmintSmartWallet.${prop}`,
+          () => this.execute(target, prop, originalMethod, args, crossmintChain)
+        );
+      }
+    });
+  }
+  async execute(target, prop, originalMethod, args, crossmintChain) {
+    try {
+      this.logger.log(`[CrossmintSmartWallet.${prop}] - params: ${stringify(args)}`);
+      const processed = isTxnMethod(prop) ? this.processTxnArgs(prop, crossmintChain, args) : args;
+      return await originalMethod.call(target, ...processed);
+    } catch (error) {
+      const description = isTxnMethod(prop) ? "signing" : "sending transaction";
+      throw this.errorProcessor.map(
+        error,
+        new SmartWalletError(`Error ${description}: ${error.message}`, stringify(error))
+      );
+    }
+  }
+  processTxnArgs(prop, crossmintChain, args) {
+    if (prop === "sendUserOperation") {
+      const [{ userOperation, middleware, account }] = args;
+      return [
+        {
+          middleware,
+          account,
+          userOperation: this.addGelatoBundlerProperties(crossmintChain, userOperation)
+        },
+        ...args.slice(1)
+      ];
+    }
+    const [txn] = args;
+    return [this.addGelatoBundlerProperties(crossmintChain, txn), ...args.slice(1)];
+  }
+  /*
+   * Chain that ZD uses Gelato as for bundler require special parameters:
+   * https://docs.zerodev.app/sdk/faqs/use-with-gelato#transaction-configuration
+   */
+  addGelatoBundlerProperties(crossmintChain, txnParams) {
+    if (usesGelatoBundler(crossmintChain)) {
+      return { ...txnParams, maxFeePerGas: "0x0", maxPriorityFeePerGas: "0x0" };
+    }
+    return txnParams;
+  }
+};
+
+export {
+  ClientDecorator
+};
+//# sourceMappingURL=chunk-QFMVSQA5.js.map

package/dist/chunk-QFMVSQA5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/clientDecorator.ts"],"sourcesContent":["import type { SmartAccountClient } from \"permissionless\";\nimport type { EntryPoint } from \"permissionless/types/entrypoint\";\nimport { stringify } from \"viem\";\n\nimport { SmartWalletError } from \"../../error\";\nimport type { ErrorProcessor } from \"../../error/processor\";\nimport { scwLogger } from \"../../services\";\nimport { usesGelatoBundler } from \"../../utils/blockchain\";\nimport type { SmartWalletChain } from \"../chains\";\n\nconst transactionMethods = [\n    \"sendTransaction\",\n    \"writeContract\",\n    \"sendUserOperation\",\n] as const satisfies readonly (keyof SmartAccountClient<EntryPoint>)[];\n\nconst signingMethods = [\n    \"signMessage\",\n    \"signTypedData\",\n] as const satisfies readonly (keyof SmartAccountClient<EntryPoint>)[];\n\ntype TxnMethod = (typeof transactionMethods)[number];\ntype SignMethod = (typeof signingMethods)[number];\n\nfunction isTxnMethod(method: string): method is TxnMethod {\n    return transactionMethods.includes(method as any);\n}\n\nfunction isSignMethod(method: string): method is SignMethod {\n    return signingMethods.includes(method as any);\n}\n\n/**\n * A decorator class for SmartAccountClient instances. It enhances the client with:\n * - Error handling & logging.\n * - Performance metrics.\n * - Automatic formatting of transactions for Gelato bundler compatibility.\n *  */\nexport class ClientDecorator {\n    constructor(\n        private readonly errorProcessor: ErrorProcessor,\n        protected logger = scwLogger\n    ) {}\n\n    public decorate<Client extends SmartAccountClient<EntryPoint>>({\n        crossmintChain,\n        smartAccountClient,\n    }: {\n        crossmintChain: SmartWalletChain;\n        smartAccountClient: Client;\n    }): Client {\n        return new Proxy(smartAccountClient, {\n            get: (target, prop, receiver) => {\n                const originalMethod = Reflect.get(target, prop, receiver);\n\n                if (\n                    typeof originalMethod !== \"function\" ||\n                    typeof prop !== \"string\" ||\n                    !(isSignMethod(prop) || isTxnMethod(prop))\n                ) {\n                    return originalMethod;\n                }\n\n                return (...args: any[]) =>\n                    this.logger.logPerformance(`CrossmintSmartWallet.${prop}`, () =>\n                        this.execute(target, prop, originalMethod, args, crossmintChain)\n                    );\n            },\n        }) as Client;\n    }\n\n    private async execute<M extends TxnMethod | SignMethod>(\n        target: SmartAccountClient<EntryPoint>,\n        prop: M,\n        originalMethod: Function,\n        args: any[],\n        crossmintChain: SmartWalletChain\n    ) {\n        try {\n            this.logger.log(`[CrossmintSmartWallet.${prop}] - params: ${stringify(args)}`);\n            const processed = isTxnMethod(prop) ? this.processTxnArgs(prop, crossmintChain, args) : args;\n            return await originalMethod.call(target, ...processed);\n        } catch (error: any) {\n            const description = isTxnMethod(prop) ? \"signing\" : \"sending transaction\";\n            throw this.errorProcessor.map(\n                error,\n                new SmartWalletError(`Error ${description}: ${error.message}`, stringify(error))\n            );\n        }\n    }\n\n    private processTxnArgs(prop: TxnMethod, crossmintChain: SmartWalletChain, args: any[]): any[] {\n        if (prop === \"sendUserOperation\") {\n            const [{ userOperation, middleware, account }] = args as Parameters<\n                SmartAccountClient<EntryPoint>[\"sendUserOperation\"]\n            >;\n            return [\n                {\n                    middleware,\n                    account,\n                    userOperation: this.addGelatoBundlerProperties(crossmintChain, userOperation),\n                },\n                ...args.slice(1),\n            ];\n        }\n\n        const [txn] = args as\n            | Parameters<SmartAccountClient<EntryPoint>[\"sendTransaction\"]>\n            | Parameters<SmartAccountClient<EntryPoint>[\"writeContract\"]>;\n\n        return [this.addGelatoBundlerProperties(crossmintChain, txn), ...args.slice(1)];\n    }\n\n    /*\n     * Chain that ZD uses Gelato as for bundler require special parameters:\n     * https://docs.zerodev.app/sdk/faqs/use-with-gelato#transaction-configuration\n     */\n    private addGelatoBundlerProperties(\n        crossmintChain: SmartWalletChain,\n        txnParams: { maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint }\n    ) {\n        if (usesGelatoBundler(crossmintChain)) {\n            return { ...txnParams, maxFeePerGas: \"0x0\" as any, maxPriorityFeePerGas: \"0x0\" as any };\n        }\n\n        return txnParams;\n    }\n}\n"],"mappings":";;;;;;;;;;;AAEA,SAAS,iBAAiB;AAQ1B,IAAM,qBAAqB;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AACJ;AAEA,IAAM,iBAAiB;AAAA,EACnB;AAAA,EACA;AACJ;AAKA,SAAS,YAAY,QAAqC;AACtD,SAAO,mBAAmB,SAAS,MAAa;AACpD;AAEA,SAAS,aAAa,QAAsC;AACxD,SAAO,eAAe,SAAS,MAAa;AAChD;AAQO,IAAM,kBAAN,MAAsB;AAAA,EACzB,YACqB,gBACP,SAAS,WACrB;AAFmB;AACP;AAAA,EACX;AAAA,EAEI,SAAwD;AAAA,IAC3D;AAAA,IACA;AAAA,EACJ,GAGW;AACP,WAAO,IAAI,MAAM,oBAAoB;AAAA,MACjC,KAAK,CAAC,QAAQ,MAAM,aAAa;AAC7B,cAAM,iBAAiB,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAEzD,YACI,OAAO,mBAAmB,cAC1B,OAAO,SAAS,YAChB,EAAE,aAAa,IAAI,KAAK,YAAY,IAAI,IAC1C;AACE,iBAAO;AAAA,QACX;AAEA,eAAO,IAAI,SACP,KAAK,OAAO;AAAA,UAAe,wBAAwB,IAAI;AAAA,UAAI,MACvD,KAAK,QAAQ,QAAQ,MAAM,gBAAgB,MAAM,cAAc;AAAA,QACnE;AAAA,MACR;AAAA,IACJ,CAAC;AAAA,EACL;AAAA,EAEA,MAAc,QACV,QACA,MACA,gBACA,MACA,gBACF;AACE,QAAI;AACA,WAAK,OAAO,IAAI,yBAAyB,IAAI,eAAe,UAAU,IAAI,CAAC,EAAE;AAC7E,YAAM,YAAY,YAAY,IAAI,IAAI,KAAK,eAAe,MAAM,gBAAgB,IAAI,IAAI;AACxF,aAAO,MAAM,eAAe,KAAK,QAAQ,GAAG,SAAS;AAAA,IACzD,SAAS,OAAY;AACjB,YAAM,cAAc,YAAY,IAAI,IAAI,YAAY;AACpD,YAAM,KAAK,eAAe;AAAA,QACtB;AAAA,QACA,IAAI,iBAAiB,SAAS,WAAW,KAAK,MAAM,OAAO,IAAI,UAAU,KAAK,CAAC;AAAA,MACnF;AAAA,IACJ;AAAA,EACJ;AAAA,EAEQ,eAAe,MAAiB,gBAAkC,MAAoB;AAC1F,QAAI,SAAS,qBAAqB;AAC9B,YAAM,CAAC,EAAE,eAAe,YAAY,QAAQ,CAAC,IAAI;AAGjD,aAAO;AAAA,QACH;AAAA,UACI;AAAA,UACA;AAAA,UACA,eAAe,KAAK,2BAA2B,gBAAgB,aAAa;AAAA,QAChF;AAAA,QACA,GAAG,KAAK,MAAM,CAAC;AAAA,MACnB;AAAA,IACJ;AAEA,UAAM,CAAC,GAAG,IAAI;AAId,WAAO,CAAC,KAAK,2BAA2B,gBAAgB,GAAG,GAAG,GAAG,KAAK,MAAM,CAAC,CAAC;AAAA,EAClF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,2BACJ,gBACA,WACF;AACE,QAAI,kBAAkB,cAAc,GAAG;AACnC,aAAO,EAAE,GAAG,WAAW,cAAc,OAAc,sBAAsB,MAAa;AAAA,IAC1F;AAEA,WAAO;AAAA,EACX;AACJ;","names":[]}

package/dist/chunk-QJ3BSVGV.js

@@ -0,0 +1,36 @@
+import {
+  usesGelatoBundler
+} from "./chunk-JOB7STIS.js";
+
+// src/blockchain/wallets/paymaster.ts
+function usePaymaster(chain) {
+  return !usesGelatoBundler(chain);
+}
+function paymasterMiddleware({
+  bundlerClient,
+  entryPoint,
+  chain,
+  walletService,
+  user
+}) {
+  return {
+    middleware: {
+      gasPrice: async () => (await bundlerClient.getUserOperationGasPrice()).fast,
+      sponsorUserOperation: async ({ userOperation }) => {
+        const { sponsorUserOpParams } = await walletService.sponsorUserOperation(
+          user,
+          userOperation,
+          entryPoint,
+          chain
+        );
+        return sponsorUserOpParams;
+      }
+    }
+  };
+}
+
+export {
+  usePaymaster,
+  paymasterMiddleware
+};
+//# sourceMappingURL=chunk-QJ3BSVGV.js.map

package/dist/chunk-QJ3BSVGV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/paymaster.ts"],"sourcesContent":["import type { CrossmintWalletService } from \"@/api/CrossmintWalletService\";\nimport type { Middleware } from \"permissionless/actions/smartAccount\";\nimport type { PimlicoBundlerClient } from \"permissionless/clients/pimlico\";\nimport type { EntryPoint } from \"permissionless/types/entrypoint\";\n\nimport type { UserParams } from \"../../types/params\";\nimport { usesGelatoBundler } from \"../../utils/blockchain\";\nimport type { SmartWalletChain } from \"../chains\";\n\nexport function usePaymaster(chain: SmartWalletChain) {\n    return !usesGelatoBundler(chain);\n}\n\nexport function paymasterMiddleware({\n    bundlerClient,\n    entryPoint,\n    chain,\n    walletService,\n    user,\n}: {\n    bundlerClient: PimlicoBundlerClient<EntryPoint>;\n    entryPoint: EntryPoint;\n    chain: SmartWalletChain;\n    walletService: CrossmintWalletService;\n    user: UserParams;\n}): Middleware<EntryPoint> {\n    return {\n        middleware: {\n            gasPrice: async () => (await bundlerClient.getUserOperationGasPrice()).fast,\n            sponsorUserOperation: async ({ userOperation }) => {\n                const { sponsorUserOpParams } = await walletService.sponsorUserOperation(\n                    user,\n                    userOperation,\n                    entryPoint,\n                    chain\n                );\n                return sponsorUserOpParams;\n            },\n        },\n    };\n}\n"],"mappings":";;;;;AASO,SAAS,aAAa,OAAyB;AAClD,SAAO,CAAC,kBAAkB,KAAK;AACnC;AAEO,SAAS,oBAAoB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GAM2B;AACvB,SAAO;AAAA,IACH,YAAY;AAAA,MACR,UAAU,aAAa,MAAM,cAAc,yBAAyB,GAAG;AAAA,MACvE,sBAAsB,OAAO,EAAE,cAAc,MAAM;AAC/C,cAAM,EAAE,oBAAoB,IAAI,MAAM,cAAc;AAAA,UAChD;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACJ;AACA,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACJ;AACJ;","names":[]}

package/dist/chunk-QZWWILWQ.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk5EHCB2XXcjs = require('./chunk-5EHCB2XX.cjs');
+
+// src/types/internal.ts
+function isSupportedKernelVersion(version) {
+  return _chunk5EHCB2XXcjs.SUPPORTED_KERNEL_VERSIONS.includes(version);
+}
+function isSupportedEntryPointVersion(version) {
+  return _chunk5EHCB2XXcjs.SUPPORTED_ENTRYPOINT_VERSIONS.includes(version);
+}
+function isPasskeyWalletParams(params) {
+  return "signer" in params && "type" in params.signer && params.signer.type === "PASSKEY";
+}
+function isPasskeyCreationContext(params) {
+  const signerIsPasskeyOrUndefined = params.existing == null || params.existing.signerConfig.type === "passkeys";
+  return isPasskeyWalletParams(params.walletParams) && signerIsPasskeyOrUndefined;
+}
+function isEOAWalletParams(params) {
+  return "signer" in params && ("type" in params.signer && params.signer.type === "VIEM_ACCOUNT" || "request" in params.signer && typeof params.signer.request === "function");
+}
+function isEOACreationContext(params) {
+  const signerIsEOAOrUndefined = params.existing == null || params.existing.signerConfig.type === "eoa";
+  return isEOAWalletParams(params.walletParams) && signerIsEOAOrUndefined;
+}
+
+
+
+
+
+
+
+
+exports.isSupportedKernelVersion = isSupportedKernelVersion; exports.isSupportedEntryPointVersion = isSupportedEntryPointVersion; exports.isPasskeyWalletParams = isPasskeyWalletParams; exports.isPasskeyCreationContext = isPasskeyCreationContext; exports.isEOAWalletParams = isEOAWalletParams; exports.isEOACreationContext = isEOACreationContext;
+//# sourceMappingURL=chunk-QZWWILWQ.cjs.map

package/dist/chunk-QZWWILWQ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/internal.ts"],"names":[],"mappings":";;;;;;AAYO,SAAS,yBAAyB,SAAoD;AACzF,SAAO,0BAA0B,SAAS,OAAc;AAC5D;AAGO,SAAS,6BAA6B,SAAwD;AACjG,SAAO,8BAA8B,SAAS,OAAc;AAChE;AA2BO,SAAS,sBAAsB,QAA0E;AAC5G,SAAO,YAAY,UAAU,UAAU,OAAO,UAAU,OAAO,OAAO,SAAS;AACnF;AAEO,SAAS,yBAAyB,QAAiE;AACtG,QAAM,6BAA6B,OAAO,YAAY,QAAQ,OAAO,SAAS,aAAa,SAAS;AAEpG,SAAO,sBAAsB,OAAO,YAAY,KAAK;AACzD;AAEO,SAAS,kBAAkB,QAA2E;AACzG,SACI,YAAY,WACV,UAAU,OAAO,UAAU,OAAO,OAAO,SAAS,kBAC/C,aAAa,OAAO,UAAU,OAAO,OAAO,OAAO,YAAY;AAE5E;AAEO,SAAS,qBAAqB,QAA6D;AAC9F,QAAM,yBAAyB,OAAO,YAAY,QAAQ,OAAO,SAAS,aAAa,SAAS;AAEhG,SAAO,kBAAkB,OAAO,YAAY,KAAK;AACrD","sourcesContent":["import type { KernelSmartAccount } from \"@zerodev/sdk\";\nimport type { SmartAccountClient } from \"permissionless\";\nimport type { SmartAccount } from \"permissionless/accounts\";\nimport type { EntryPoint } from \"permissionless/types/entrypoint\";\nimport type { Address, Chain, HttpTransport, PublicClient } from \"viem\";\n\nimport type { SmartWalletChain } from \"../blockchain/chains\";\nimport type { EOASignerConfig, PasskeySignerConfig, SignerConfig } from \"../blockchain/wallets/account/signer\";\nimport { SUPPORTED_ENTRYPOINT_VERSIONS, SUPPORTED_KERNEL_VERSIONS } from \"../utils/constants\";\nimport type { ExternalSigner, PasskeySigner, UserParams, WalletParams } from \"./params\";\n\nexport type SupportedKernelVersion = (typeof SUPPORTED_KERNEL_VERSIONS)[number];\nexport function isSupportedKernelVersion(version: string): version is SupportedKernelVersion {\n    return SUPPORTED_KERNEL_VERSIONS.includes(version as any);\n}\n\nexport type SupportedEntryPointVersion = (typeof SUPPORTED_ENTRYPOINT_VERSIONS)[number];\nexport function isSupportedEntryPointVersion(version: string): version is SupportedEntryPointVersion {\n    return SUPPORTED_ENTRYPOINT_VERSIONS.includes(version as any);\n}\n\nexport interface PreExistingWalletProperties {\n    signerConfig: SignerConfig;\n    address: Address;\n}\n\nexport interface WalletCreationContext {\n    user: UserParams & { id: string };\n    chain: SmartWalletChain;\n    publicClient: PublicClient<HttpTransport>;\n    walletParams: WalletParams;\n    entryPoint: EntryPoint;\n    kernelVersion: SupportedKernelVersion;\n    existing?: PreExistingWalletProperties;\n}\n\nexport interface PasskeyCreationContext extends WalletCreationContext {\n    walletParams: WalletParams & { signer: PasskeySigner };\n    existing?: { signerConfig: PasskeySignerConfig; address: Address };\n}\n\nexport interface EOACreationContext extends WalletCreationContext {\n    walletParams: WalletParams & { signer: ExternalSigner };\n    existing?: { signerConfig: EOASignerConfig; address: Address };\n}\n\nexport function isPasskeyWalletParams(params: WalletParams): params is WalletParams & { signer: PasskeySigner } {\n    return \"signer\" in params && \"type\" in params.signer && params.signer.type === \"PASSKEY\";\n}\n\nexport function isPasskeyCreationContext(params: WalletCreationContext): params is PasskeyCreationContext {\n    const signerIsPasskeyOrUndefined = params.existing == null || params.existing.signerConfig.type === \"passkeys\";\n\n    return isPasskeyWalletParams(params.walletParams) && signerIsPasskeyOrUndefined;\n}\n\nexport function isEOAWalletParams(params: WalletParams): params is WalletParams & { signer: ExternalSigner } {\n    return (\n        \"signer\" in params &&\n        ((\"type\" in params.signer && params.signer.type === \"VIEM_ACCOUNT\") ||\n            (\"request\" in params.signer && typeof params.signer.request === \"function\"))\n    );\n}\n\nexport function isEOACreationContext(params: WalletCreationContext): params is EOACreationContext {\n    const signerIsEOAOrUndefined = params.existing == null || params.existing.signerConfig.type === \"eoa\";\n\n    return isEOAWalletParams(params.walletParams) && signerIsEOAOrUndefined;\n}\n\nexport interface AccountAndSigner {\n    account: KernelSmartAccount<EntryPoint, HttpTransport>;\n    signerConfig: SignerConfig;\n}\n\nexport type SmartWalletClient = SmartAccountClient<EntryPoint, HttpTransport, Chain, SmartAccount<EntryPoint>>;\n"]}

package/dist/chunk-SEA2NTT5.js

@@ -0,0 +1,22 @@
+// package.json
+var version = "0.1.22";
+
+// src/utils/constants.ts
+var ZERO_DEV_TYPE = "ZeroDev";
+var CURRENT_VERSION = 0;
+var SCW_SERVICE = "SCW_SDK";
+var SDK_VERSION = version;
+var API_VERSION = "2024-06-09";
+var SUPPORTED_KERNEL_VERSIONS = ["0.3.1", "0.3.0", "0.2.4"];
+var SUPPORTED_ENTRYPOINT_VERSIONS = ["v0.6", "v0.7"];
+
+export {
+  ZERO_DEV_TYPE,
+  CURRENT_VERSION,
+  SCW_SERVICE,
+  SDK_VERSION,
+  API_VERSION,
+  SUPPORTED_KERNEL_VERSIONS,
+  SUPPORTED_ENTRYPOINT_VERSIONS
+};
+//# sourceMappingURL=chunk-SEA2NTT5.js.map

package/dist/chunk-SEA2NTT5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../package.json","../src/utils/constants.ts"],"sourcesContent":["{\n    \"name\": \"@crossmint/client-sdk-smart-wallet\",\n    \"version\": \"0.1.22\",\n    \"repository\": \"https://github.com/Crossmint/crossmint-sdk\",\n    \"license\": \"Apache-2.0\",\n    \"author\": \"Paella Labs Inc\",\n    \"sideEffects\": false,\n    \"type\": \"module\",\n    \"exports\": {\n        \"import\": \"./dist/index.js\",\n        \"require\": \"./dist/index.cjs\"\n    },\n    \"main\": \"./dist/index.cjs\",\n    \"module\": \"./dist/index.js\",\n    \"types\": \"./dist/index.d.ts\",\n    \"files\": [\"dist\", \"src\", \"LICENSE\"],\n    \"scripts\": {\n        \"build\": \"tsup\",\n        \"dev\": \"tsup --watch\",\n        \"test:vitest\": \"vitest run\"\n    },\n    \"dependencies\": {\n        \"@crossmint/client-sdk-base\": \"workspace:*\",\n        \"@crossmint/common-sdk-base\": \"workspace:*\",\n        \"@zerodev/ecdsa-validator\": \"5.3.1\",\n        \"@zerodev/passkey-validator\": \"5.4.0\",\n        \"@zerodev/sdk\": \"5.3.3\",\n        \"@zerodev/webauthn-key\": \"5.3.1\",\n        \"permissionless\": \"0.1.36\",\n        \"viem\": \"2.17.5\",\n        \"zod\": \"3.22.4\"\n    },\n    \"devDependencies\": {\n        \"typedoc\": \"0.26.5\",\n        \"typedoc-plugin-frontmatter\": \"1.0.0\",\n        \"typedoc-plugin-markdown\": \"4.2.3\"\n    }\n}\n","import { version } from \"../../package.json\";\n\nexport const ZERO_DEV_TYPE = \"ZeroDev\";\nexport const CURRENT_VERSION = 0;\nexport const SCW_SERVICE = \"SCW_SDK\";\nexport const SDK_VERSION = version;\nexport const API_VERSION = \"2024-06-09\";\nexport const SUPPORTED_KERNEL_VERSIONS = [\"0.3.1\", \"0.3.0\", \"0.2.4\"] as const;\nexport const SUPPORTED_ENTRYPOINT_VERSIONS = [\"v0.6\", \"v0.7\"] as const;\n"],"mappings":";AAEI,cAAW;;;ACAR,IAAM,gBAAgB;AACtB,IAAM,kBAAkB;AACxB,IAAM,cAAc;AACpB,IAAM,cAAc;AACpB,IAAM,cAAc;AACpB,IAAM,4BAA4B,CAAC,SAAS,SAAS,OAAO;AAC5D,IAAM,gCAAgC,CAAC,QAAQ,MAAM;","names":[]}

package/dist/chunk-SMDX2MXU.js

@@ -0,0 +1,13 @@
+// src/utils/helpers.ts
+function isEmpty(str) {
+  return !str || str.length === 0 || str.trim().length === 0;
+}
+function equalsIgnoreCase(a, b) {
+  return a?.toLowerCase() === b?.toLowerCase();
+}
+
+export {
+  isEmpty,
+  equalsIgnoreCase
+};
+//# sourceMappingURL=chunk-SMDX2MXU.js.map

package/dist/chunk-SMDX2MXU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/helpers.ts"],"sourcesContent":["export function isEmpty(str: string | undefined | null): str is undefined | null {\n    return !str || str.length === 0 || str.trim().length === 0;\n}\n\nexport function equalsIgnoreCase(a?: string, b?: string): boolean {\n    return a?.toLowerCase() === b?.toLowerCase();\n}\n"],"mappings":";AAAO,SAAS,QAAQ,KAAyD;AAC7E,SAAO,CAAC,OAAO,IAAI,WAAW,KAAK,IAAI,KAAK,EAAE,WAAW;AAC7D;AAEO,SAAS,iBAAiB,GAAY,GAAqB;AAC9D,SAAO,GAAG,YAAY,MAAM,GAAG,YAAY;AAC/C;","names":[]}

package/dist/chunk-TDJDKTRS.js

@@ -0,0 +1,156 @@
+import {
+  PasskeySignerConfig
+} from "./chunk-3R6PW6HY.js";
+import {
+  PasskeyIncompatibleAuthenticatorError,
+  PasskeyMismatchError,
+  PasskeyPromptError,
+  PasskeyRegistrationError
+} from "./chunk-ASIPMVRQ.js";
+
+// src/blockchain/wallets/account/passkey.ts
+import { PasskeyValidatorContractVersion, WebAuthnMode, toPasskeyValidator } from "@zerodev/passkey-validator";
+import { createKernelAccount } from "@zerodev/sdk";
+import { toWebAuthnKey } from "@zerodev/webauthn-key";
+var PasskeyCreationStrategy = class {
+  constructor(passkeyServerUrl, apiKey) {
+    this.passkeyServerUrl = passkeyServerUrl;
+    this.apiKey = apiKey;
+  }
+  async create({
+    user,
+    publicClient,
+    walletParams,
+    entryPoint,
+    kernelVersion,
+    existing
+  }) {
+    const inputPasskeyName = walletParams.signer.passkeyName ?? user.id;
+    if (existing != null && existing.signerConfig.data.passkeyName !== inputPasskeyName) {
+      throw new PasskeyMismatchError(
+        `User '${user.id}' has an existing wallet created with a passkey named '${existing.signerConfig.data.passkeyName}', this does match input passkey name '${inputPasskeyName}'.`,
+        existing.signerConfig.display()
+      );
+    }
+    try {
+      if (existing == null && walletParams.signer.onPrePasskeyRegistration != null) {
+        await walletParams.signer.onPrePasskeyRegistration();
+      }
+      const passkey = await this.getPasskey(user, inputPasskeyName, existing?.signerConfig.data);
+      const latestValidatorVersion = PasskeyValidatorContractVersion.V0_0_2;
+      const validatorContractVersion = existing == null ? latestValidatorVersion : existing.signerConfig.data.validatorContractVersion;
+      const validator = await toPasskeyValidator(publicClient, {
+        webAuthnKey: passkey,
+        entryPoint,
+        validatorContractVersion,
+        kernelVersion
+      });
+      const kernelAccount = await createKernelAccount(publicClient, {
+        plugins: { sudo: validator },
+        entryPoint,
+        kernelVersion,
+        deployedAccountAddress: existing?.address
+      });
+      return {
+        signerConfig: this.getSignerConfig(validator, validatorContractVersion, inputPasskeyName),
+        account: this.decorate(kernelAccount, inputPasskeyName, walletParams)
+      };
+    } catch (error) {
+      if (walletParams.signer.onPasskeyRegistrationError != null) {
+        walletParams.signer.onPasskeyRegistrationError(error);
+      }
+      throw this.mapError(error, inputPasskeyName);
+    }
+  }
+  async getPasskey(user, passkeyName, existing) {
+    if (existing != null) {
+      return {
+        pubX: BigInt(existing.pubKeyX),
+        pubY: BigInt(existing.pubKeyY),
+        authenticatorId: existing.authenticatorId,
+        authenticatorIdHash: existing.authenticatorIdHash
+      };
+    }
+    return toWebAuthnKey({
+      passkeyName,
+      passkeyServerUrl: this.passkeyServerUrl,
+      mode: WebAuthnMode.Register,
+      passkeyServerHeaders: this.createPasskeysServerHeaders(user)
+    });
+  }
+  getSignerConfig(validator, validatorContractVersion, passkeyName) {
+    return new PasskeySignerConfig({
+      ...deserializePasskeyValidatorData(validator.getSerializedData()),
+      passkeyName,
+      validatorContractVersion,
+      domain: window.location.hostname,
+      type: "passkeys"
+    });
+  }
+  createPasskeysServerHeaders(user) {
+    return {
+      "x-api-key": this.apiKey,
+      Authorization: `Bearer ${user.jwt}`
+    };
+  }
+  mapError(error, passkeyName) {
+    if (error.code === 0 && error.name === "DataError") {
+      return new PasskeyIncompatibleAuthenticatorError(passkeyName);
+    }
+    if (error.message === "Registration not verified") {
+      return new PasskeyRegistrationError(passkeyName);
+    }
+    if (error.code === "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY" && error.name === "NotAllowedError") {
+      return new PasskeyPromptError(passkeyName);
+    }
+    return error;
+  }
+  decorate(account, passkeyName, walletParams) {
+    return new Proxy(account, {
+      get: (target, prop, receiver) => {
+        const original = Reflect.get(target, prop, receiver);
+        if (typeof original !== "function" || typeof prop !== "string" || !isAccountSigningMethod(prop)) {
+          return original;
+        }
+        const signer = walletParams.signer;
+        return async (...args) => {
+          const isFirstTransaction = args?.[0]?.factoryData != null;
+          if (isFirstTransaction && prop === "signUserOperation" && signer.type === "PASSKEY" && signer.onFirstTimePasskeySigning != null) {
+            await signer.onFirstTimePasskeySigning();
+          }
+          try {
+            return await original.call(target, ...args);
+          } catch (error) {
+            if (signer.onFirstTimePasskeySigningError != null) {
+              await signer.onFirstTimePasskeySigningError(error);
+            }
+            throw this.mapError(error, passkeyName);
+          }
+        };
+      }
+    });
+  }
+};
+var accountSigningMethods = [
+  "signMessage",
+  "signTypedData",
+  "signUserOperation",
+  "signTransaction"
+];
+function isAccountSigningMethod(method) {
+  return accountSigningMethods.includes(method);
+}
+var deserializePasskeyValidatorData = (params) => {
+  const uint8Array = base64ToBytes(params);
+  const jsonString = new TextDecoder().decode(uint8Array);
+  return JSON.parse(jsonString);
+};
+function base64ToBytes(base64) {
+  const binString = atob(base64);
+  return Uint8Array.from(binString, (m) => m.codePointAt(0));
+}
+
+export {
+  PasskeyCreationStrategy
+};
+//# sourceMappingURL=chunk-TDJDKTRS.js.map

package/dist/chunk-TDJDKTRS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/account/passkey.ts"],"sourcesContent":["import { PasskeyValidatorContractVersion, WebAuthnMode, toPasskeyValidator } from \"@zerodev/passkey-validator\";\nimport { type KernelSmartAccount, type KernelValidator, createKernelAccount } from \"@zerodev/sdk\";\nimport { type WebAuthnKey, toWebAuthnKey } from \"@zerodev/webauthn-key\";\nimport type { SmartAccount } from \"permissionless/accounts\";\nimport type { EntryPoint } from \"permissionless/types/entrypoint\";\n\nimport {\n    PasskeyIncompatibleAuthenticatorError,\n    PasskeyMismatchError,\n    PasskeyPromptError,\n    PasskeyRegistrationError,\n} from \"../../../error\";\nimport type { AccountAndSigner, PasskeyCreationContext } from \"../../../types/internal\";\nimport type { PasskeySigner, UserParams, WalletParams } from \"../../../types/params\";\nimport type { PasskeySignerData, PasskeyValidatorSerializedData } from \"../../../types/service\";\nimport { PasskeySignerConfig } from \"./signer\";\nimport type { AccountCreationStrategy } from \"./strategy\";\n\ntype PasskeyValidator = KernelValidator<EntryPoint, \"WebAuthnValidator\"> & {\n    getSerializedData: () => string;\n};\nexport class PasskeyCreationStrategy implements AccountCreationStrategy {\n    constructor(\n        private readonly passkeyServerUrl: string,\n        private readonly apiKey: string\n    ) {}\n\n    public async create({\n        user,\n        publicClient,\n        walletParams,\n        entryPoint,\n        kernelVersion,\n        existing,\n    }: PasskeyCreationContext): Promise<AccountAndSigner> {\n        const inputPasskeyName = walletParams.signer.passkeyName ?? user.id;\n        if (existing != null && existing.signerConfig.data.passkeyName !== inputPasskeyName) {\n            throw new PasskeyMismatchError(\n                `User '${user.id}' has an existing wallet created with a passkey named '${existing.signerConfig.data.passkeyName}', this does match input passkey name '${inputPasskeyName}'.`,\n                existing.signerConfig.display()\n            );\n        }\n\n        try {\n            if (existing == null && walletParams.signer.onPrePasskeyRegistration != null) {\n                await walletParams.signer.onPrePasskeyRegistration();\n            }\n\n            const passkey = await this.getPasskey(user, inputPasskeyName, existing?.signerConfig.data);\n\n            const latestValidatorVersion = PasskeyValidatorContractVersion.V0_0_2;\n            const validatorContractVersion =\n                existing == null ? latestValidatorVersion : existing.signerConfig.data.validatorContractVersion;\n\n            const validator = await toPasskeyValidator(publicClient, {\n                webAuthnKey: passkey,\n                entryPoint,\n                validatorContractVersion,\n                kernelVersion,\n            });\n\n            const kernelAccount = await createKernelAccount(publicClient, {\n                plugins: { sudo: validator },\n                entryPoint,\n                kernelVersion,\n                deployedAccountAddress: existing?.address,\n            });\n\n            return {\n                signerConfig: this.getSignerConfig(validator, validatorContractVersion, inputPasskeyName),\n                account: this.decorate(kernelAccount, inputPasskeyName, walletParams),\n            };\n        } catch (error) {\n            if (walletParams.signer.onPasskeyRegistrationError != null) {\n                walletParams.signer.onPasskeyRegistrationError(error);\n            }\n            throw this.mapError(error, inputPasskeyName);\n        }\n    }\n\n    private async getPasskey(\n        user: UserParams,\n        passkeyName: string,\n        existing?: PasskeySignerData\n    ): Promise<WebAuthnKey> {\n        if (existing != null) {\n            return {\n                pubX: BigInt(existing.pubKeyX),\n                pubY: BigInt(existing.pubKeyY),\n                authenticatorId: existing.authenticatorId,\n                authenticatorIdHash: existing.authenticatorIdHash,\n            };\n        }\n\n        return toWebAuthnKey({\n            passkeyName,\n            passkeyServerUrl: this.passkeyServerUrl,\n            mode: WebAuthnMode.Register,\n            passkeyServerHeaders: this.createPasskeysServerHeaders(user),\n        });\n    }\n\n    private getSignerConfig(\n        validator: PasskeyValidator,\n        validatorContractVersion: PasskeyValidatorContractVersion,\n        passkeyName: string\n    ): PasskeySignerConfig {\n        return new PasskeySignerConfig({\n            ...deserializePasskeyValidatorData(validator.getSerializedData()),\n            passkeyName,\n            validatorContractVersion,\n            domain: window.location.hostname,\n            type: \"passkeys\",\n        });\n    }\n\n    private createPasskeysServerHeaders(user: UserParams) {\n        return {\n            \"x-api-key\": this.apiKey,\n            Authorization: `Bearer ${user.jwt}`,\n        };\n    }\n\n    private mapError(error: any, passkeyName: string) {\n        if (error.code === 0 && error.name === \"DataError\") {\n            return new PasskeyIncompatibleAuthenticatorError(passkeyName);\n        }\n\n        if (error.message === \"Registration not verified\") {\n            return new PasskeyRegistrationError(passkeyName);\n        }\n\n        if (error.code === \"ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY\" && error.name === \"NotAllowedError\") {\n            return new PasskeyPromptError(passkeyName);\n        }\n\n        return error;\n    }\n\n    private decorate<Account extends KernelSmartAccount<EntryPoint>>(\n        account: Account,\n        passkeyName: string,\n        walletParams: WalletParams\n    ): Account {\n        return new Proxy(account, {\n            get: (target, prop, receiver) => {\n                const original = Reflect.get(target, prop, receiver);\n                if (typeof original !== \"function\" || typeof prop !== \"string\" || !isAccountSigningMethod(prop)) {\n                    return original;\n                }\n\n                const signer = walletParams.signer as PasskeySigner;\n                return async (...args: any[]) => {\n                    const isFirstTransaction = args?.[0]?.factoryData != null;\n                    if (\n                        isFirstTransaction &&\n                        prop === \"signUserOperation\" &&\n                        signer.type === \"PASSKEY\" &&\n                        signer.onFirstTimePasskeySigning != null\n                    ) {\n                        await signer.onFirstTimePasskeySigning();\n                    }\n                    try {\n                        return await original.call(target, ...args);\n                    } catch (error) {\n                        if (signer.onFirstTimePasskeySigningError != null) {\n                            await signer.onFirstTimePasskeySigningError(error);\n                        }\n                        throw this.mapError(error, passkeyName);\n                    }\n                };\n            },\n        });\n    }\n}\n\nconst accountSigningMethods = [\n    \"signMessage\",\n    \"signTypedData\",\n    \"signUserOperation\",\n    \"signTransaction\",\n] as const satisfies readonly (keyof SmartAccount<EntryPoint>)[];\n\nfunction isAccountSigningMethod(method: string): method is (typeof accountSigningMethods)[number] {\n    return accountSigningMethods.includes(method as any);\n}\n\nconst deserializePasskeyValidatorData = (params: string) => {\n    const uint8Array = base64ToBytes(params);\n    const jsonString = new TextDecoder().decode(uint8Array);\n\n    return JSON.parse(jsonString) as PasskeyValidatorSerializedData;\n};\n\nfunction base64ToBytes(base64: string) {\n    const binString = atob(base64);\n    return Uint8Array.from(binString, (m) => m.codePointAt(0) as number);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-U4OBHCIP.js

@@ -0,0 +1,59 @@
+import {
+  EOASignerConfig
+} from "./chunk-3R6PW6HY.js";
+import {
+  equalsIgnoreCase
+} from "./chunk-SMDX2MXU.js";
+import {
+  createOwnerSigner
+} from "./chunk-EQSMHR77.js";
+import {
+  AdminMismatchError
+} from "./chunk-ASIPMVRQ.js";
+
+// src/blockchain/wallets/account/eoa.ts
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import { createKernelAccount } from "@zerodev/sdk";
+var EOACreationStrategy = class {
+  async create({
+    chain,
+    publicClient,
+    entryPoint,
+    walletParams,
+    kernelVersion,
+    user,
+    existing
+  }) {
+    const eoa = await createOwnerSigner({
+      chain,
+      walletParams
+    });
+    if (existing != null && !equalsIgnoreCase(eoa.address, existing.signerConfig.data.eoaAddress)) {
+      throw new AdminMismatchError(
+        `User '${user.id}' has an existing wallet with an eoa signer '${existing.signerConfig.data.eoaAddress}', this does not match input eoa signer '${eoa.address}'.`,
+        existing.signerConfig.display(),
+        { type: "eoa", eoaAddress: existing.signerConfig.data.eoaAddress }
+      );
+    }
+    const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+      signer: eoa,
+      entryPoint,
+      kernelVersion
+    });
+    const account = await createKernelAccount(publicClient, {
+      plugins: {
+        sudo: ecdsaValidator
+      },
+      index: 0n,
+      entryPoint,
+      kernelVersion,
+      deployedAccountAddress: existing?.address
+    });
+    return { account, signerConfig: new EOASignerConfig({ eoaAddress: eoa.address, type: "eoa" }) };
+  }
+};
+
+export {
+  EOACreationStrategy
+};
+//# sourceMappingURL=chunk-U4OBHCIP.js.map

package/dist/chunk-U4OBHCIP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/account/eoa.ts"],"sourcesContent":["import { signerToEcdsaValidator } from \"@zerodev/ecdsa-validator\";\nimport { createKernelAccount } from \"@zerodev/sdk\";\n\nimport { AdminMismatchError } from \"../../../error\";\nimport type { AccountAndSigner, EOACreationContext } from \"../../../types/internal\";\nimport { equalsIgnoreCase } from \"../../../utils/helpers\";\nimport { createOwnerSigner } from \"../../../utils/signer\";\nimport { EOASignerConfig } from \"./signer\";\nimport type { AccountCreationStrategy } from \"./strategy\";\n\nexport class EOACreationStrategy implements AccountCreationStrategy {\n    public async create({\n        chain,\n        publicClient,\n        entryPoint,\n        walletParams,\n        kernelVersion,\n        user,\n        existing,\n    }: EOACreationContext): Promise<AccountAndSigner> {\n        const eoa = await createOwnerSigner({\n            chain,\n            walletParams,\n        });\n\n        if (existing != null && !equalsIgnoreCase(eoa.address, existing.signerConfig.data.eoaAddress)) {\n            throw new AdminMismatchError(\n                `User '${user.id}' has an existing wallet with an eoa signer '${existing.signerConfig.data.eoaAddress}', this does not match input eoa signer '${eoa.address}'.`,\n                existing.signerConfig.display(),\n                { type: \"eoa\", eoaAddress: existing.signerConfig.data.eoaAddress }\n            );\n        }\n\n        const ecdsaValidator = await signerToEcdsaValidator(publicClient, {\n            signer: eoa,\n            entryPoint,\n            kernelVersion,\n        });\n        const account = await createKernelAccount(publicClient, {\n            plugins: {\n                sudo: ecdsaValidator,\n            },\n            index: 0n,\n            entryPoint,\n            kernelVersion,\n            deployedAccountAddress: existing?.address,\n        });\n\n        return { account, signerConfig: new EOASignerConfig({ eoaAddress: eoa.address, type: \"eoa\" }) };\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA,SAAS,8BAA8B;AACvC,SAAS,2BAA2B;AAS7B,IAAM,sBAAN,MAA6D;AAAA,EAChE,MAAa,OAAO;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ,GAAkD;AAC9C,UAAM,MAAM,MAAM,kBAAkB;AAAA,MAChC;AAAA,MACA;AAAA,IACJ,CAAC;AAED,QAAI,YAAY,QAAQ,CAAC,iBAAiB,IAAI,SAAS,SAAS,aAAa,KAAK,UAAU,GAAG;AAC3F,YAAM,IAAI;AAAA,QACN,SAAS,KAAK,EAAE,gDAAgD,SAAS,aAAa,KAAK,UAAU,4CAA4C,IAAI,OAAO;AAAA,QAC5J,SAAS,aAAa,QAAQ;AAAA,QAC9B,EAAE,MAAM,OAAO,YAAY,SAAS,aAAa,KAAK,WAAW;AAAA,MACrE;AAAA,IACJ;AAEA,UAAM,iBAAiB,MAAM,uBAAuB,cAAc;AAAA,MAC9D,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACJ,CAAC;AACD,UAAM,UAAU,MAAM,oBAAoB,cAAc;AAAA,MACpD,SAAS;AAAA,QACL,MAAM;AAAA,MACV;AAAA,MACA,OAAO;AAAA,MACP;AAAA,MACA;AAAA,MACA,wBAAwB,UAAU;AAAA,IACtC,CAAC;AAED,WAAO,EAAE,SAAS,cAAc,IAAI,gBAAgB,EAAE,YAAY,IAAI,SAAS,MAAM,MAAM,CAAC,EAAE;AAAA,EAClG;AACJ;","names":[]}

package/dist/chunk-UQKE6R5W.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/blockchain/rpc.ts
+var _commonsdkbase = require('@crossmint/common-sdk-base');
+var ALCHEMY_API_KEY = "-7M6vRDBDknwvMxnqah_jbcieWg0qad9";
+var PIMLICO_API_KEY = "pim_9dKmQPxiTCvtbUNF7XFBbA";
+var ALCHEMY_RPC_SUBDOMAIN = {
+  polygon: "polygon-mainnet",
+  "polygon-amoy": "polygon-amoy",
+  base: "base-mainnet",
+  "base-sepolia": "base-sepolia",
+  optimism: "opt-mainnet",
+  "optimism-sepolia": "opt-sepolia",
+  arbitrum: "arb-mainnet",
+  "arbitrum-sepolia": "arb-sepolia"
+};
+function getAlchemyRPC(chain) {
+  return `https://${ALCHEMY_RPC_SUBDOMAIN[chain]}.g.alchemy.com/v2/${ALCHEMY_API_KEY}`;
+}
+function getPimlicoBundlerRPC(chain) {
+  return `https://api.pimlico.io/v2/${_commonsdkbase.blockchainToChainId.call(void 0, chain)}/rpc?apikey=${PIMLICO_API_KEY}`;
+}
+
+
+
+
+
+exports.ALCHEMY_RPC_SUBDOMAIN = ALCHEMY_RPC_SUBDOMAIN; exports.getAlchemyRPC = getAlchemyRPC; exports.getPimlicoBundlerRPC = getPimlicoBundlerRPC;
+//# sourceMappingURL=chunk-UQKE6R5W.cjs.map

package/dist/chunk-UQKE6R5W.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/rpc.ts"],"names":[],"mappings":";AAAA,SAAS,2BAA2B;AAIpC,IAAM,kBAAkB;AACxB,IAAM,kBAAkB;AAEjB,IAAM,wBAA0D;AAAA,EACnE,SAAS;AAAA,EACT,gBAAgB;AAAA,EAChB,MAAM;AAAA,EACN,gBAAgB;AAAA,EAChB,UAAU;AAAA,EACV,oBAAoB;AAAA,EACpB,UAAU;AAAA,EACV,oBAAoB;AACxB;AAEO,SAAS,cAAc,OAAiC;AAC3D,SAAO,WAAW,sBAAsB,KAAK,CAAC,qBAAqB,eAAe;AACtF;AAEO,SAAS,qBAAqB,OAAiC;AAClE,SAAO,6BAA6B,oBAAoB,KAAK,CAAC,eAAe,eAAe;AAChG","sourcesContent":["import { blockchainToChainId } from \"@crossmint/common-sdk-base\";\n\nimport type { SmartWalletChain } from \"./chains\";\n\nconst ALCHEMY_API_KEY = \"-7M6vRDBDknwvMxnqah_jbcieWg0qad9\";\nconst PIMLICO_API_KEY = \"pim_9dKmQPxiTCvtbUNF7XFBbA\";\n\nexport const ALCHEMY_RPC_SUBDOMAIN: Record<SmartWalletChain, string> = {\n    polygon: \"polygon-mainnet\",\n    \"polygon-amoy\": \"polygon-amoy\",\n    base: \"base-mainnet\",\n    \"base-sepolia\": \"base-sepolia\",\n    optimism: \"opt-mainnet\",\n    \"optimism-sepolia\": \"opt-sepolia\",\n    arbitrum: \"arb-mainnet\",\n    \"arbitrum-sepolia\": \"arb-sepolia\",\n};\n\nexport function getAlchemyRPC(chain: SmartWalletChain): string {\n    return `https://${ALCHEMY_RPC_SUBDOMAIN[chain]}.g.alchemy.com/v2/${ALCHEMY_API_KEY}`;\n}\n\nexport function getPimlicoBundlerRPC(chain: SmartWalletChain): string {\n    return `https://api.pimlico.io/v2/${blockchainToChainId(chain)}/rpc?apikey=${PIMLICO_API_KEY}`;\n}\n"]}