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

package/dist/chunk-N6DG5EZG.cjs

@@ -0,0 +1,156 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkZOXKITU4cjs = require('./chunk-ZOXKITU4.cjs');
+
+
+
+
+
+var _chunkBXSAJOIVcjs = require('./chunk-BXSAJOIV.cjs');
+
+// src/blockchain/wallets/account/passkey.ts
+var _passkeyvalidator = require('@zerodev/passkey-validator');
+var _sdk = require('@zerodev/sdk');
+var _webauthnkey = require('@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 = _nullishCoalesce(walletParams.signer.passkeyName, () => ( user.id));
+    if (existing != null && existing.signerConfig.data.passkeyName !== inputPasskeyName) {
+      throw new (0, _chunkBXSAJOIVcjs.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, _optionalChain([existing, 'optionalAccess', _ => _.signerConfig, 'access', _2 => _2.data]));
+      const latestValidatorVersion = _passkeyvalidator.PasskeyValidatorContractVersion.V0_0_2;
+      const validatorContractVersion = existing == null ? latestValidatorVersion : existing.signerConfig.data.validatorContractVersion;
+      const validator = await _passkeyvalidator.toPasskeyValidator.call(void 0, publicClient, {
+        webAuthnKey: passkey,
+        entryPoint,
+        validatorContractVersion,
+        kernelVersion
+      });
+      const kernelAccount = await _sdk.createKernelAccount.call(void 0, publicClient, {
+        plugins: { sudo: validator },
+        entryPoint,
+        kernelVersion,
+        deployedAccountAddress: _optionalChain([existing, 'optionalAccess', _3 => _3.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 _webauthnkey.toWebAuthnKey.call(void 0, {
+      passkeyName,
+      passkeyServerUrl: this.passkeyServerUrl,
+      mode: _passkeyvalidator.WebAuthnMode.Register,
+      passkeyServerHeaders: this.createPasskeysServerHeaders(user)
+    });
+  }
+  getSignerConfig(validator, validatorContractVersion, passkeyName) {
+    return new (0, _chunkZOXKITU4cjs.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 (0, _chunkBXSAJOIVcjs.PasskeyIncompatibleAuthenticatorError)(passkeyName);
+    }
+    if (error.message === "Registration not verified") {
+      return new (0, _chunkBXSAJOIVcjs.PasskeyRegistrationError)(passkeyName);
+    }
+    if (error.code === "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY" && error.name === "NotAllowedError") {
+      return new (0, _chunkBXSAJOIVcjs.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 = _optionalChain([args, 'optionalAccess', _4 => _4[0], 'optionalAccess', _5 => _5.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));
+}
+
+
+
+exports.PasskeyCreationStrategy = PasskeyCreationStrategy;
+//# sourceMappingURL=chunk-N6DG5EZG.cjs.map

package/dist/chunk-N6DG5EZG.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/account/passkey.ts"],"names":[],"mappings":"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","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"]}

package/dist/chunk-NXDZHR5C.js

@@ -0,0 +1,99 @@
+import {
+  paymasterMiddleware,
+  usePaymaster
+} from "./chunk-QJ3BSVGV.js";
+import {
+  EVMSmartWallet
+} from "./chunk-UZGHOTKZ.js";
+import {
+  viemNetworks
+} from "./chunk-6NJVFL2X.js";
+import {
+  getAlchemyRPC,
+  getPimlicoBundlerRPC
+} from "./chunk-BARW756O.js";
+import {
+  CURRENT_VERSION,
+  ZERO_DEV_TYPE
+} from "./chunk-UDDYHPSW.js";
+
+// src/blockchain/wallets/service.ts
+import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07, createSmartAccountClient } from "permissionless";
+import { createPimlicoBundlerClient } from "permissionless/clients/pimlico";
+import { createPublicClient, http } from "viem";
+import { blockchainToChainId } from "@crossmint/common-sdk-base";
+var SmartWalletService = class {
+  constructor(crossmintService, accountConfigService, accountCreator, clientDecorator) {
+    this.crossmintService = crossmintService;
+    this.accountConfigService = accountConfigService;
+    this.accountCreator = accountCreator;
+    this.clientDecorator = clientDecorator;
+  }
+  async getOrCreate(user, chain, walletParams) {
+    const {
+      config: { entryPointVersion, kernelVersion, existing, userWithId },
+      cached
+    } = await this.accountConfigService.get(user, chain);
+    const publicClient = createPublicClient({ transport: http(getAlchemyRPC(chain)) });
+    const { account, signerConfig } = await this.accountCreator.get({
+      chain,
+      walletParams,
+      publicClient,
+      user: userWithId,
+      entryPoint: entryPointVersion === "v0.6" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,
+      kernelVersion,
+      existing
+    });
+    if (existing == null) {
+      await this.crossmintService.idempotentCreateSmartWallet(user, {
+        type: ZERO_DEV_TYPE,
+        smartContractWalletAddress: account.address,
+        signerData: signerConfig.data,
+        version: CURRENT_VERSION,
+        baseLayer: "evm",
+        chainId: blockchainToChainId(chain),
+        entryPointVersion,
+        kernelVersion
+      });
+    }
+    if (!cached) {
+      this.accountConfigService.cache({
+        entryPointVersion,
+        kernelVersion,
+        user: userWithId,
+        existing: { address: account.address, signerConfig }
+      });
+    }
+    return new EVMSmartWallet(
+      { wallet: this.smartAccountClient(chain, account, user), public: publicClient },
+      chain,
+      this.crossmintService
+    );
+  }
+  smartAccountClient(chain, account, user) {
+    const transport = http(getPimlicoBundlerRPC(chain));
+    const bundlerConfig = { chain: viemNetworks[chain], entryPoint: account.entryPoint };
+    const bundlerClient = createPimlicoBundlerClient({ ...bundlerConfig, transport });
+    const smartAccountClient = createSmartAccountClient({
+      account,
+      bundlerTransport: transport,
+      ...bundlerConfig,
+      ...usePaymaster(chain) && paymasterMiddleware({
+        bundlerClient,
+        entryPoint: account.entryPoint,
+        chain,
+        walletService: this.crossmintService,
+        user
+      })
+    });
+    return this.clientDecorator.decorate({
+      crossmintChain: chain,
+      smartAccountClient
+    });
+  }
+};
+
+export {
+  SmartWalletService
+};
+//# sourceMappingURL=chunk-NXDZHR5C.js.map

package/dist/chunk-NXDZHR5C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/service.ts"],"sourcesContent":["import type { KernelSmartAccount } from \"@zerodev/sdk\";\nimport { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07, createSmartAccountClient } from \"permissionless\";\nimport { createPimlicoBundlerClient } from \"permissionless/clients/pimlico\";\nimport type { EntryPoint } from \"permissionless/types/entrypoint\";\nimport { type HttpTransport, createPublicClient, http } from \"viem\";\n\nimport { blockchainToChainId } from \"@crossmint/common-sdk-base\";\n\nimport type { CrossmintWalletService } from \"../../api/CrossmintWalletService\";\nimport type { SmartWalletClient } from \"../../types/internal\";\nimport type { UserParams, WalletParams } from \"../../types/params\";\nimport { CURRENT_VERSION, ZERO_DEV_TYPE } from \"../../utils/constants\";\nimport { type SmartWalletChain, viemNetworks } from \"../chains\";\nimport { getAlchemyRPC, getPimlicoBundlerRPC } from \"../rpc\";\nimport { EVMSmartWallet } from \"./EVMSmartWallet\";\nimport type { AccountConfigService } from \"./account/config\";\nimport type { AccountCreator } from \"./account/creator\";\nimport type { ClientDecorator } from \"./clientDecorator\";\nimport { paymasterMiddleware, usePaymaster } from \"./paymaster\";\n\nexport class SmartWalletService {\n    constructor(\n        private readonly crossmintService: CrossmintWalletService,\n        private readonly accountConfigService: AccountConfigService,\n        private readonly accountCreator: AccountCreator,\n        private readonly clientDecorator: ClientDecorator\n    ) {}\n\n    public async getOrCreate(\n        user: UserParams,\n        chain: SmartWalletChain,\n        walletParams: WalletParams\n    ): Promise<EVMSmartWallet> {\n        const {\n            config: { entryPointVersion, kernelVersion, existing, userWithId },\n            cached,\n        } = await this.accountConfigService.get(user, chain);\n\n        const publicClient = createPublicClient({ transport: http(getAlchemyRPC(chain)) });\n\n        const { account, signerConfig } = await this.accountCreator.get({\n            chain,\n            walletParams,\n            publicClient,\n            user: userWithId,\n            entryPoint: entryPointVersion === \"v0.6\" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,\n            kernelVersion,\n            existing,\n        });\n\n        if (existing == null) {\n            await this.crossmintService.idempotentCreateSmartWallet(user, {\n                type: ZERO_DEV_TYPE,\n                smartContractWalletAddress: account.address,\n                signerData: signerConfig.data,\n                version: CURRENT_VERSION,\n                baseLayer: \"evm\",\n                chainId: blockchainToChainId(chain),\n                entryPointVersion,\n                kernelVersion,\n            });\n        }\n\n        if (!cached) {\n            this.accountConfigService.cache({\n                entryPointVersion,\n                kernelVersion,\n                user: userWithId,\n                existing: { address: account.address, signerConfig },\n            });\n        }\n\n        return new EVMSmartWallet(\n            { wallet: this.smartAccountClient(chain, account, user), public: publicClient },\n            chain,\n            this.crossmintService\n        );\n    }\n\n    private smartAccountClient(\n        chain: SmartWalletChain,\n        account: KernelSmartAccount<EntryPoint, HttpTransport>,\n        user: UserParams\n    ): SmartWalletClient {\n        const transport = http(getPimlicoBundlerRPC(chain));\n        const bundlerConfig = { chain: viemNetworks[chain], entryPoint: account.entryPoint };\n        const bundlerClient = createPimlicoBundlerClient({ ...bundlerConfig, transport });\n        const smartAccountClient: SmartWalletClient = createSmartAccountClient({\n            account,\n            bundlerTransport: transport,\n            ...bundlerConfig,\n            ...(usePaymaster(chain) &&\n                paymasterMiddleware({\n                    bundlerClient,\n                    entryPoint: account.entryPoint,\n                    chain,\n                    walletService: this.crossmintService,\n                    user,\n                })),\n        });\n\n        return this.clientDecorator.decorate({\n            crossmintChain: chain,\n            smartAccountClient,\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AACA,SAAS,wBAAwB,wBAAwB,gCAAgC;AACzF,SAAS,kCAAkC;AAE3C,SAA6B,oBAAoB,YAAY;AAE7D,SAAS,2BAA2B;AAc7B,IAAM,qBAAN,MAAyB;AAAA,EAC5B,YACqB,kBACA,sBACA,gBACA,iBACnB;AAJmB;AACA;AACA;AACA;AAAA,EAClB;AAAA,EAEH,MAAa,YACT,MACA,OACA,cACuB;AACvB,UAAM;AAAA,MACF,QAAQ,EAAE,mBAAmB,eAAe,UAAU,WAAW;AAAA,MACjE;AAAA,IACJ,IAAI,MAAM,KAAK,qBAAqB,IAAI,MAAM,KAAK;AAEnD,UAAM,eAAe,mBAAmB,EAAE,WAAW,KAAK,cAAc,KAAK,CAAC,EAAE,CAAC;AAEjF,UAAM,EAAE,SAAS,aAAa,IAAI,MAAM,KAAK,eAAe,IAAI;AAAA,MAC5D;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,YAAY,sBAAsB,SAAS,yBAAyB;AAAA,MACpE;AAAA,MACA;AAAA,IACJ,CAAC;AAED,QAAI,YAAY,MAAM;AAClB,YAAM,KAAK,iBAAiB,4BAA4B,MAAM;AAAA,QAC1D,MAAM;AAAA,QACN,4BAA4B,QAAQ;AAAA,QACpC,YAAY,aAAa;AAAA,QACzB,SAAS;AAAA,QACT,WAAW;AAAA,QACX,SAAS,oBAAoB,KAAK;AAAA,QAClC;AAAA,QACA;AAAA,MACJ,CAAC;AAAA,IACL;AAEA,QAAI,CAAC,QAAQ;AACT,WAAK,qBAAqB,MAAM;AAAA,QAC5B;AAAA,QACA;AAAA,QACA,MAAM;AAAA,QACN,UAAU,EAAE,SAAS,QAAQ,SAAS,aAAa;AAAA,MACvD,CAAC;AAAA,IACL;AAEA,WAAO,IAAI;AAAA,MACP,EAAE,QAAQ,KAAK,mBAAmB,OAAO,SAAS,IAAI,GAAG,QAAQ,aAAa;AAAA,MAC9E;AAAA,MACA,KAAK;AAAA,IACT;AAAA,EACJ;AAAA,EAEQ,mBACJ,OACA,SACA,MACiB;AACjB,UAAM,YAAY,KAAK,qBAAqB,KAAK,CAAC;AAClD,UAAM,gBAAgB,EAAE,OAAO,aAAa,KAAK,GAAG,YAAY,QAAQ,WAAW;AACnF,UAAM,gBAAgB,2BAA2B,EAAE,GAAG,eAAe,UAAU,CAAC;AAChF,UAAM,qBAAwC,yBAAyB;AAAA,MACnE;AAAA,MACA,kBAAkB;AAAA,MAClB,GAAG;AAAA,MACH,GAAI,aAAa,KAAK,KAClB,oBAAoB;AAAA,QAChB;AAAA,QACA,YAAY,QAAQ;AAAA,QACpB;AAAA,QACA,eAAe,KAAK;AAAA,QACpB;AAAA,MACJ,CAAC;AAAA,IACT,CAAC;AAED,WAAO,KAAK,gBAAgB,SAAS;AAAA,MACjC,gBAAgB;AAAA,MAChB;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;","names":[]}

package/dist/chunk-O6IFYHDP.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/api.ts
+var _viem = require('viem');
+function mapObject(data, fn) {
+  const result = fn(data);
+  if (result.replace) {
+    return result.value;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => mapObject(item, fn));
+  } else if (data !== null && typeof data === "object") {
+    return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, mapObject(value, fn)]));
+  }
+  return result.value;
+}
+function bigintsToHex(data) {
+  return mapObject(data, (value) => {
+    if (typeof value === "bigint") {
+      return { value: _viem.toHex.call(void 0, value), replace: true };
+    }
+    return { value, replace: false };
+  });
+}
+function parseBigintAPIResponse(data) {
+  return mapObject(data, (value) => {
+    if (value != null && typeof value == "object" && "__xm_serializedType" in value && "value" in value && value.__xm_serializedType === "bigint" && typeof value.value === "string") {
+      return { value: BigInt(value.value), replace: true };
+    }
+    return { value, replace: false };
+  });
+}
+
+
+
+
+exports.bigintsToHex = bigintsToHex; exports.parseBigintAPIResponse = parseBigintAPIResponse;
+//# sourceMappingURL=chunk-O6IFYHDP.cjs.map

package/dist/chunk-O6IFYHDP.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/api.ts"],"names":[],"mappings":";AAAA,SAAS,aAAa;AAEtB,SAAS,UAAU,MAAW,IAAmE;AAC7F,QAAM,SAAS,GAAG,IAAI;AACtB,MAAI,OAAO,SAAS;AAChB,WAAO,OAAO;AAAA,EAClB;AACA,MAAI,MAAM,QAAQ,IAAI,GAAG;AACrB,WAAO,KAAK,IAAI,CAAC,SAAS,UAAU,MAAM,EAAE,CAAC;AAAA,EACjD,WAAW,SAAS,QAAQ,OAAO,SAAS,UAAU;AAClD,WAAO,OAAO,YAAY,OAAO,QAAQ,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,EAAE,CAAC,CAAC,CAAC;AAAA,EACrG;AACA,SAAO,OAAO;AAClB;AAEO,SAAS,aAAa,MAAgB;AACzC,SAAO,UAAU,MAAM,CAAC,UAAU;AAC9B,QAAI,OAAO,UAAU,UAAU;AAC3B,aAAO,EAAE,OAAO,MAAM,KAAK,GAAG,SAAS,KAAK;AAAA,IAChD;AACA,WAAO,EAAE,OAAO,SAAS,MAAM;AAAA,EACnC,CAAC;AACL;AAEO,SAAS,uBAAuB,MAAgB;AACnD,SAAO,UAAU,MAAM,CAAC,UAAU;AAC9B,QACI,SAAS,QACT,OAAO,SAAS,YAChB,yBAAyB,SACzB,WAAW,SACX,MAAM,wBAAwB,YAC9B,OAAO,MAAM,UAAU,UACzB;AACE,aAAO,EAAE,OAAO,OAAO,MAAM,KAAK,GAAG,SAAS,KAAK;AAAA,IACvD;AACA,WAAO,EAAE,OAAO,SAAS,MAAM;AAAA,EACnC,CAAC;AACL","sourcesContent":["import { toHex } from \"viem\";\n\nfunction mapObject(data: any, fn: (value: unknown) => { value: unknown; replace: boolean }): any {\n    const result = fn(data);\n    if (result.replace) {\n        return result.value;\n    }\n    if (Array.isArray(data)) {\n        return data.map((item) => mapObject(item, fn));\n    } else if (data !== null && typeof data === \"object\") {\n        return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, mapObject(value, fn)]));\n    }\n    return result.value;\n}\n\nexport function bigintsToHex(data: any): any {\n    return mapObject(data, (value) => {\n        if (typeof value === \"bigint\") {\n            return { value: toHex(value), replace: true };\n        }\n        return { value, replace: false };\n    });\n}\n\nexport function parseBigintAPIResponse(data: any): any {\n    return mapObject(data, (value) => {\n        if (\n            value != null &&\n            typeof value == \"object\" &&\n            \"__xm_serializedType\" in value &&\n            \"value\" in value &&\n            value.__xm_serializedType === \"bigint\" &&\n            typeof value.value === \"string\"\n        ) {\n            return { value: BigInt(value.value), replace: true };\n        }\n        return { value, replace: false };\n    });\n}\n"]}

package/dist/chunk-OCG67QSU.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkGLHQIT4Qcjs = require('./chunk-GLHQIT4Q.cjs');
+
+
+
+var _chunkBXSAJOIVcjs = require('./chunk-BXSAJOIV.cjs');
+
+// src/blockchain/wallets/account/creator.ts
+var AccountCreator = class {
+  constructor(eoaStrategy, passkeyStrategy) {
+    this.eoaStrategy = eoaStrategy;
+    this.passkeyStrategy = passkeyStrategy;
+  }
+  get(context) {
+    if (_chunkGLHQIT4Qcjs.isPasskeyCreationContext.call(void 0, context)) {
+      return this.passkeyStrategy.create(context);
+    }
+    if (_chunkGLHQIT4Qcjs.isEOACreationContext.call(void 0, context)) {
+      return this.eoaStrategy.create(context);
+    }
+    if (context.existing == null) {
+      throw new (0, _chunkBXSAJOIVcjs.ConfigError)(`Unsupported wallet params:
+${context.walletParams}`);
+    }
+    const display = context.existing.signerConfig.display();
+    const inputSignerType = _chunkGLHQIT4Qcjs.isPasskeyWalletParams.call(void 0, context.walletParams) ? "passkey" : "eoa";
+    throw new (0, _chunkBXSAJOIVcjs.AdminMismatchError)(
+      `Cannot create wallet with ${inputSignerType} signer for user ${context.user.id}', they already have a wallet with signer:
+'${JSON.stringify(display, null, 2)}'`,
+      display
+    );
+  }
+};
+
+
+
+exports.AccountCreator = AccountCreator;
+//# sourceMappingURL=chunk-OCG67QSU.cjs.map

package/dist/chunk-OCG67QSU.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/account/creator.ts"],"names":[],"mappings":";;;;;;;;;;;AAWO,IAAM,iBAAN,MAAqB;AAAA,EACxB,YACqB,aACA,iBACnB;AAFmB;AACA;AAAA,EAClB;AAAA,EAEI,IAAI,SAA2D;AAClE,QAAI,yBAAyB,OAAO,GAAG;AACnC,aAAO,KAAK,gBAAgB,OAAO,OAAO;AAAA,IAC9C;AAEA,QAAI,qBAAqB,OAAO,GAAG;AAC/B,aAAO,KAAK,YAAY,OAAO,OAAO;AAAA,IAC1C;AAEA,QAAI,QAAQ,YAAY,MAAM;AAC1B,YAAM,IAAI,YAAY;AAAA,EAA+B,QAAQ,YAAY,EAAE;AAAA,IAC/E;AAEA,UAAM,UAAU,QAAQ,SAAS,aAAa,QAAQ;AACtD,UAAM,kBAAkB,sBAAsB,QAAQ,YAAY,IAAI,YAAY;AAClF,UAAM,IAAI;AAAA,MACN,6BAA6B,eAAe,oBACxC,QAAQ,KAAK,EACjB;AAAA,GAAgD,KAAK,UAAU,SAAS,MAAM,CAAC,CAAC;AAAA,MAChF;AAAA,IACJ;AAAA,EACJ;AACJ","sourcesContent":["import { AdminMismatchError, ConfigError } from \"../../../error\";\nimport {\n    type AccountAndSigner,\n    type WalletCreationContext,\n    isEOACreationContext,\n    isPasskeyCreationContext,\n    isPasskeyWalletParams,\n} from \"../../../types/internal\";\nimport type { EOACreationStrategy } from \"./eoa\";\nimport type { PasskeyCreationStrategy } from \"./passkey\";\n\nexport class AccountCreator {\n    constructor(\n        private readonly eoaStrategy: EOACreationStrategy,\n        private readonly passkeyStrategy: PasskeyCreationStrategy\n    ) {}\n\n    public get(context: WalletCreationContext): Promise<AccountAndSigner> {\n        if (isPasskeyCreationContext(context)) {\n            return this.passkeyStrategy.create(context);\n        }\n\n        if (isEOACreationContext(context)) {\n            return this.eoaStrategy.create(context);\n        }\n\n        if (context.existing == null) {\n            throw new ConfigError(`Unsupported wallet params:\\n${context.walletParams}`);\n        }\n\n        const display = context.existing.signerConfig.display();\n        const inputSignerType = isPasskeyWalletParams(context.walletParams) ? \"passkey\" : \"eoa\";\n        throw new AdminMismatchError(\n            `Cannot create wallet with ${inputSignerType} signer for user ${\n                context.user.id\n            }', they already have a wallet with signer:\\n'${JSON.stringify(display, null, 2)}'`,\n            display\n        );\n    }\n}\n"]}

package/dist/chunk-OGA3YDWS.cjs

@@ -0,0 +1,112 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk7KTQNIAZcjs = require('./chunk-7KTQNIAZ.cjs');
+
+
+var _chunk5WVQ7J3Ecjs = require('./chunk-5WVQ7J3E.cjs');
+
+
+var _chunkBXSAJOIVcjs = require('./chunk-BXSAJOIV.cjs');
+
+// src/blockchain/wallets/EVMSmartWallet.ts
+var EVMSmartWallet = class {
+  constructor(client, chain, crossmintService, sendTransactionService = new (0, _chunk7KTQNIAZcjs.SendTransactionService)(client)) {
+    this.crossmintService = crossmintService;
+    this.sendTransactionService = sendTransactionService;
+    this.chain = chain;
+    this.client = client;
+  }
+  /**
+   * The address of the smart wallet.
+   */
+  get address() {
+    return this.client.wallet.account.address;
+  }
+  /**
+   * Transfers tokens from the smart wallet to a specified address.
+   * @param toAddress The recipient's address.
+   * @param config The transfer configuration, including token details and amount.
+   * @returns The transaction hash.
+   * @throws {SmartWalletError} If there's a chain mismatch between this wallet and the input configuration.
+   * @throws {SendTransactionError} If the transaction fails to send. Contains the error thrown by the viem client.
+   * @throws {SendTransactionExecutionRevertedError} A subclass of SendTransactionError if the transaction fails due to a contract execution error.
+   */
+  async transferToken(toAddress, config) {
+    if (this.chain !== config.token.chain) {
+      throw new (0, _chunkBXSAJOIVcjs.SmartWalletError)(
+        `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`
+      );
+    }
+    return this.executeContract(
+      _chunk5WVQ7J3Ecjs.transferParams.call(void 0, {
+        contract: config.token.contractAddress,
+        to: toAddress,
+        from: this.client.wallet.account,
+        config
+      })
+    );
+  }
+  /**
+   * @returns A list of NFTs owned by the wallet.
+   */
+  async nfts() {
+    return this.crossmintService.fetchNFTs(this.address, this.chain);
+  }
+  /**
+   * Sends a contract call transaction and returns the hash of a confirmed transaction.
+   * @param address the address of the contract to be called
+   * @param abi the ABI of the contract - ***should be defined as a typed variable*** to enable type checking of the contract arguments, see https://viem.sh/docs/typescript#type-inference for guidance
+   * @param functionName the name of the smart contract function to be called
+   * @param args the arguments to be passed to the function
+   * @returns The transaction hash.
+   * @throws `SendTransactionError` if the transaction fails to send. Contains the error thrown by the viem client.
+   * @throws `SendTransactionExecutionRevertedError`, a subclass of `SendTransactionError` if the transaction fails due to a contract execution error.
+   *
+   * **Passing a typed ABI:**
+   * @example
+   * const abi = [{
+   *   "inputs": [
+   *     {
+   *       "internalType": "address",
+   *         "name": "recipient",
+   *         "type": "address"
+   *       },
+   *   ],
+   *   "name": "mintNFT",
+   *   "outputs": [],
+   *   "stateMutability": "nonpayable",
+   *   "type": "function"
+   * }] as const;
+   *
+   * await wallet.executeContract({
+   *   address: contractAddress,
+   *   abi,
+   *   functionName: "mintNFT",
+   *   args: [recipientAddress],
+   * });
+   */
+  async executeContract({
+    address,
+    abi,
+    functionName,
+    args,
+    value,
+    config
+  }) {
+    return this.sendTransactionService.sendTransaction(
+      {
+        address,
+        abi,
+        functionName,
+        args,
+        value
+      },
+      config
+    );
+  }
+};
+
+
+
+exports.EVMSmartWallet = EVMSmartWallet;
+//# sourceMappingURL=chunk-OGA3YDWS.cjs.map

package/dist/chunk-OGA3YDWS.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/blockchain/wallets/EVMSmartWallet.ts"],"names":[],"mappings":";;;;;;;;;;;AAuBO,IAAM,iBAAN,MAAqB;AAAA,EAkBxB,YACI,QACA,OACiB,kBACA,yBAAyB,IAAI,uBAAuB,MAAM,GAC7E;AAFmB;AACA;AAEjB,SAAK,QAAQ;AACb,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAW,UAAU;AACjB,WAAO,KAAK,OAAO,OAAO,QAAQ;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAa,cAAc,WAAoB,QAAuC;AAClF,QAAI,KAAK,UAAU,OAAO,MAAM,OAAO;AACnC,YAAM,IAAI;AAAA,QACN,4BAA4B,OAAO,MAAM,KAAK,aAAa,KAAK,KAAK;AAAA,MACzE;AAAA,IACJ;AAEA,WAAO,KAAK;AAAA,MACR,eAAe;AAAA,QACX,UAAU,OAAO,MAAM;AAAA,QACvB,IAAI;AAAA,QACJ,MAAM,KAAK,OAAO,OAAO;AAAA,QACzB;AAAA,MACJ,CAAC;AAAA,IACL;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,OAAO;AAChB,WAAO,KAAK,iBAAiB,UAAU,KAAK,SAAS,KAAK,KAAK;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmCA,MAAa,gBAWX;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ,GAEiB;AACb,WAAO,KAAK,uBAAuB;AAAA,MAC/B;AAAA,QACI;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACJ;AAAA,MACA;AAAA,IACJ;AAAA,EACJ;AACJ","sourcesContent":["import type {\n    Abi,\n    Address,\n    ContractFunctionArgs,\n    ContractFunctionName,\n    Hex,\n    HttpTransport,\n    PublicClient,\n    WriteContractParameters,\n} from \"viem\";\n\nimport type { CrossmintWalletService } from \"../../api/CrossmintWalletService\";\nimport { SmartWalletError } from \"../../error\";\nimport type { SmartWalletClient } from \"../../types/internal\";\nimport type { TransferType } from \"../../types/token\";\nimport type { SmartWalletChain } from \"../chains\";\nimport { transferParams } from \"../transfer\";\nimport { type SendTransactionOptions, SendTransactionService } from \"./SendTransactionService\";\n\n/**\n * Smart wallet interface for EVM chains enhanced with Crossmint capabilities.\n * Core functionality is exposed via [viem](https://viem.sh/) clients within the `client` property of the class.\n */\nexport class EVMSmartWallet {\n    public readonly chain: SmartWalletChain;\n\n    /**\n     * [viem](https://viem.sh/) clients that provide an interface for core wallet functionality.\n     */\n    public readonly client: {\n        /**\n         * An interface to interact with the smart wallet, execute transactions, sign messages, etc.\n         */\n        wallet: SmartWalletClient;\n\n        /**\n         * An interface to read onchain data, fetch transactions, retrieve account balances, etc. Corresponds to public [JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/) methods.\n         */\n        public: PublicClient;\n    };\n\n    constructor(\n        client: { public: PublicClient<HttpTransport>; wallet: SmartWalletClient },\n        chain: SmartWalletChain,\n        private readonly crossmintService: CrossmintWalletService,\n        private readonly sendTransactionService = new SendTransactionService(client)\n    ) {\n        this.chain = chain;\n        this.client = client;\n    }\n\n    /**\n     * The address of the smart wallet.\n     */\n    public get address() {\n        return this.client.wallet.account.address;\n    }\n\n    /**\n     * Transfers tokens from the smart wallet to a specified address.\n     * @param toAddress The recipient's address.\n     * @param config The transfer configuration, including token details and amount.\n     * @returns The transaction hash.\n     * @throws {SmartWalletError} If there's a chain mismatch between this wallet and the input configuration.\n     * @throws {SendTransactionError} If the transaction fails to send. Contains the error thrown by the viem client.\n     * @throws {SendTransactionExecutionRevertedError} A subclass of SendTransactionError if the transaction fails due to a contract execution error.\n     */\n    public async transferToken(toAddress: Address, config: TransferType): Promise<string> {\n        if (this.chain !== config.token.chain) {\n            throw new SmartWalletError(\n                `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`\n            );\n        }\n\n        return this.executeContract(\n            transferParams({\n                contract: config.token.contractAddress,\n                to: toAddress,\n                from: this.client.wallet.account,\n                config,\n            })\n        );\n    }\n\n    /**\n     * @returns A list of NFTs owned by the wallet.\n     */\n    public async nfts() {\n        return this.crossmintService.fetchNFTs(this.address, this.chain);\n    }\n\n    /**\n     * Sends a contract call transaction and returns the hash of a confirmed transaction.\n     * @param address the address of the contract to be called\n     * @param abi the ABI of the contract - ***should be defined as a typed variable*** to enable type checking of the contract arguments, see https://viem.sh/docs/typescript#type-inference for guidance\n     * @param functionName the name of the smart contract function to be called\n     * @param args the arguments to be passed to the function\n     * @returns The transaction hash.\n     * @throws `SendTransactionError` if the transaction fails to send. Contains the error thrown by the viem client.\n     * @throws `SendTransactionExecutionRevertedError`, a subclass of `SendTransactionError` if the transaction fails due to a contract execution error.\n     *\n     * **Passing a typed ABI:**\n     * @example\n     * const abi = [{\n     *   \"inputs\": [\n     *     {\n     *       \"internalType\": \"address\",\n     *         \"name\": \"recipient\",\n     *         \"type\": \"address\"\n     *       },\n     *   ],\n     *   \"name\": \"mintNFT\",\n     *   \"outputs\": [],\n     *   \"stateMutability\": \"nonpayable\",\n     *   \"type\": \"function\"\n     * }] as const;\n     *\n     * await wallet.executeContract({\n     *   address: contractAddress,\n     *   abi,\n     *   functionName: \"mintNFT\",\n     *   args: [recipientAddress],\n     * });\n     */\n    public async executeContract<\n        const TAbi extends Abi | readonly unknown[],\n        TFunctionName extends ContractFunctionName<TAbi, \"nonpayable\" | \"payable\"> = ContractFunctionName<\n            TAbi,\n            \"nonpayable\" | \"payable\"\n        >,\n        TArgs extends ContractFunctionArgs<TAbi, \"nonpayable\" | \"payable\", TFunctionName> = ContractFunctionArgs<\n            TAbi,\n            \"nonpayable\" | \"payable\",\n            TFunctionName\n        >,\n    >({\n        address,\n        abi,\n        functionName,\n        args,\n        value,\n        config,\n    }: Omit<WriteContractParameters<TAbi, TFunctionName, TArgs>, \"chain\" | \"account\"> & {\n        config?: Partial<SendTransactionOptions>;\n    }): Promise<Hex> {\n        return this.sendTransactionService.sendTransaction(\n            {\n                address,\n                abi: abi as Abi,\n                functionName,\n                args,\n                value,\n            },\n            config\n        );\n    }\n}\n"]}