@crossmint/wallets-sdk 0.18.3 → 0.18.6

package/dist/chunk-S5YXROL6.js

@@ -0,0 +1,301 @@
+import {
+  compareSignerConfigs,
+  normalizeValueForComparison
+} from "./chunk-ZP4ZZCIE.js";
+import {
+  Wallet
+} from "./chunk-UKBWSQ7R.js";
+import {
+  assembleSigner
+} from "./chunk-TOHXQVLS.js";
+import {
+  WalletCreationError,
+  WalletNotAvailableError
+} from "./chunk-SGINWAB6.js";
+import {
+  walletsLogger
+} from "./chunk-RAWKXOHR.js";
+import {
+  __async,
+  __spreadValues
+} from "./chunk-FPMW7Q5O.js";
+
+// src/wallets/wallet-factory.ts
+import { WebAuthnP256 } from "ox";
+var DELEGATED_SIGNER_MISMATCH_ERROR = "When 'delegatedSigners' is provided to a method that may fetch an existing wallet, each specified delegated signer must exist in that wallet's configuration.";
+var WalletFactory = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  getOrCreateWallet(args) {
+    return __async(this, null, function* () {
+      if (this.apiClient.isServerSide) {
+        throw new WalletCreationError(
+          "getOrCreateWallet can only be called from client-side code.\n- Make sure you're running this in the browser (or another client environment), not on your server.\n- Use your Crossmint Client API Key (not a server key)."
+        );
+      }
+      const locator = this.getWalletLocator(args);
+      walletsLogger.info("wallet.getOrCreate.start", {
+        chain: args.chain,
+        signerType: args.signer.type
+      });
+      const existingWallet = yield this.apiClient.getWallet(locator);
+      if (existingWallet != null && !("error" in existingWallet)) {
+        walletsLogger.info("wallet.getOrCreate.existing", {
+          chain: args.chain,
+          address: existingWallet.address
+        });
+        return this.createWalletInstance(existingWallet, args);
+      }
+      walletsLogger.info("wallet.getOrCreate.creating", {
+        chain: args.chain
+      });
+      return this.createWallet(args);
+    });
+  }
+  getWallet(walletLocator, args) {
+    return __async(this, null, function* () {
+      if (!this.apiClient.isServerSide) {
+        throw new WalletCreationError("getWallet is not supported on client side, use getOrCreateWallet instead");
+      }
+      walletsLogger.info("wallet.get.start", {
+        walletLocator,
+        chain: args.chain
+      });
+      const existingWallet = yield this.apiClient.getWallet(walletLocator);
+      if ("error" in existingWallet) {
+        walletsLogger.warn("wallet.get.notFound", {
+          walletLocator,
+          error: existingWallet.error
+        });
+        throw new WalletNotAvailableError(JSON.stringify(existingWallet));
+      }
+      walletsLogger.info("wallet.get.success", {
+        walletLocator,
+        address: existingWallet.address
+      });
+      return this.createWalletInstance(existingWallet, args);
+    });
+  }
+  createWallet(args) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      yield (_c = (_b = (_a = args.options) == null ? void 0 : _a.experimental_callbacks) == null ? void 0 : _b.onWalletCreationStart) == null ? void 0 : _c.call(_b);
+      walletsLogger.info("wallet.create.start", {
+        chain: args.chain,
+        signerType: args.signer.type
+      });
+      this.mutateSignerFromCustomAuth(args, true);
+      const adminSigner = args.signer.type === "passkey" ? yield this.createPasskeyAdminSigner(args.signer) : args.signer;
+      const walletResponse = yield this.apiClient.createWallet({
+        type: "smart",
+        chainType: this.getChainType(args.chain),
+        config: __spreadValues(__spreadValues({
+          adminSigner
+        }, (args == null ? void 0 : args.plugins) ? { plugins: args.plugins } : {}), args.delegatedSigners != null ? { delegatedSigners: args.delegatedSigners } : {}),
+        owner: (_d = args.owner) != null ? _d : void 0,
+        alias: (_e = args.alias) != null ? _e : void 0
+      });
+      if ("error" in walletResponse) {
+        walletsLogger.error("wallet.create.error", {
+          chain: args.chain,
+          error: walletResponse.error
+        });
+        throw new WalletCreationError(JSON.stringify(walletResponse));
+      }
+      walletsLogger.info("wallet.create.success", {
+        chain: args.chain,
+        address: walletResponse.address
+      });
+      return this.createWalletInstance(walletResponse, args);
+    });
+  }
+  createWalletInstance(walletResponse, args) {
+    this.validateExistingWalletConfig(walletResponse, args);
+    const signerConfig = this.toInternalSignerConfig(walletResponse, args.signer, args.options);
+    return new Wallet(
+      {
+        chain: args.chain,
+        address: walletResponse.address,
+        owner: walletResponse.owner,
+        signer: assembleSigner(args.chain, signerConfig),
+        options: args.options,
+        alias: args.alias
+      },
+      this.apiClient
+    );
+  }
+  toInternalSignerConfig(walletResponse, signerArgs, options) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!(walletResponse.chainType === "evm" || walletResponse.chainType === "solana" || walletResponse.chainType === "stellar")) {
+      throw new WalletCreationError(`Wallet type ${walletResponse.chainType} is not supported`);
+    }
+    if (signerArgs == null && ((_a = walletResponse.config) == null ? void 0 : _a.adminSigner) == null) {
+      throw new WalletCreationError("Signer is required to create a wallet");
+    }
+    switch (signerArgs.type) {
+      case "api-key": {
+        if (((_b = walletResponse.config) == null ? void 0 : _b.adminSigner.type) !== "api-key") {
+          throw new WalletCreationError("API key signer does not match the wallet's signer type");
+        }
+        return {
+          type: "api-key",
+          address: walletResponse.config.adminSigner.address,
+          locator: walletResponse.config.adminSigner.locator
+        };
+      }
+      case "external-wallet":
+        if (((_c = walletResponse.config) == null ? void 0 : _c.adminSigner.type) !== "external-wallet") {
+          throw new WalletCreationError("External wallet signer does not match the wallet's signer type");
+        }
+        return __spreadValues(__spreadValues({}, walletResponse.config.adminSigner), signerArgs);
+      case "passkey":
+        if (((_d = walletResponse.config) == null ? void 0 : _d.adminSigner.type) !== "passkey") {
+          throw new WalletCreationError("Passkey signer does not match the wallet's signer type");
+        }
+        return {
+          type: "passkey",
+          id: walletResponse.config.adminSigner.id,
+          name: walletResponse.config.adminSigner.name,
+          locator: walletResponse.config.adminSigner.locator,
+          onCreatePasskey: signerArgs.onCreatePasskey,
+          onSignWithPasskey: signerArgs.onSignWithPasskey
+        };
+      case "email": {
+        if (((_e = walletResponse.config) == null ? void 0 : _e.adminSigner.type) !== "email") {
+          throw new WalletCreationError("Email signer does not match the wallet's signer type");
+        }
+        const { locator, email, address } = walletResponse.config.adminSigner;
+        return {
+          type: "email",
+          email,
+          locator,
+          address,
+          crossmint: this.apiClient.crossmint,
+          onAuthRequired: signerArgs.onAuthRequired,
+          clientTEEConnection: options == null ? void 0 : options.clientTEEConnection
+        };
+      }
+      case "phone": {
+        if (((_f = walletResponse.config) == null ? void 0 : _f.adminSigner.type) !== "phone") {
+          throw new WalletCreationError("Phone signer does not match the wallet's signer type");
+        }
+        const { locator, phone, address } = walletResponse.config.adminSigner;
+        return {
+          type: "phone",
+          phone,
+          locator,
+          address,
+          crossmint: this.apiClient.crossmint,
+          onAuthRequired: signerArgs.onAuthRequired,
+          clientTEEConnection: options == null ? void 0 : options.clientTEEConnection
+        };
+      }
+      default:
+        throw new Error("Invalid signer type");
+    }
+  }
+  getWalletLocator(args) {
+    return `me:${this.getChainType(args.chain)}:smart` + (args.alias != null ? `:alias:${args.alias}` : "");
+  }
+  createPasskeyAdminSigner(signer) {
+    return __async(this, null, function* () {
+      var _a;
+      if (signer.type !== "passkey") {
+        throw new Error("Signer is not a passkey");
+      }
+      const passkeyName = (_a = signer.name) != null ? _a : `Crossmint Wallet ${Date.now()}`;
+      const passkeyCredential = signer.onCreatePasskey ? yield signer.onCreatePasskey(passkeyName) : yield WebAuthnP256.createCredential({ name: passkeyName });
+      return {
+        type: "passkey",
+        id: passkeyCredential.id,
+        name: passkeyName,
+        publicKey: {
+          x: passkeyCredential.publicKey.x.toString(),
+          y: passkeyCredential.publicKey.y.toString()
+        }
+      };
+    });
+  }
+  mutateSignerFromCustomAuth(args, isNewWalletSigner = false) {
+    var _a, _b;
+    const { experimental_customAuth } = this.apiClient.crossmint;
+    if (args.signer.type === "email" && (experimental_customAuth == null ? void 0 : experimental_customAuth.email) != null) {
+      args.signer.email = (_a = args.signer.email) != null ? _a : experimental_customAuth.email;
+    }
+    if (args.signer.type === "phone" && (experimental_customAuth == null ? void 0 : experimental_customAuth.phone) != null) {
+      args.signer.phone = (_b = args.signer.phone) != null ? _b : experimental_customAuth.phone;
+    }
+    if (args.signer.type === "external-wallet" && (experimental_customAuth == null ? void 0 : experimental_customAuth.externalWalletSigner) != null) {
+      args.signer = isNewWalletSigner ? {
+        type: "external-wallet",
+        address: experimental_customAuth.externalWalletSigner.address
+      } : experimental_customAuth.externalWalletSigner;
+    }
+    return;
+  }
+  validateExistingWalletConfig(existingWallet, args) {
+    var _a;
+    this.mutateSignerFromCustomAuth(args);
+    if (args.owner != null && existingWallet.owner != null && normalizeValueForComparison(args.owner) !== normalizeValueForComparison(existingWallet.owner)) {
+      throw new WalletCreationError("Wallet owner does not match existing wallet's linked user");
+    }
+    if (args.chain === "solana" && existingWallet.chainType !== "solana" || args.chain !== "solana" && existingWallet.chainType === "solana" || args.chain === "stellar" && existingWallet.chainType !== "stellar" || args.chain !== "stellar" && existingWallet.chainType === "stellar") {
+      throw new WalletCreationError(
+        `Wallet chain does not match existing wallet's chain. You must use chain: ${existingWallet.chainType}.`
+      );
+    }
+    if (existingWallet.type !== "smart") {
+      return;
+    }
+    const adminSignerArgs = args.signer;
+    const existingWalletSigner = (_a = existingWallet == null ? void 0 : existingWallet.config) == null ? void 0 : _a.adminSigner;
+    if (adminSignerArgs != null && existingWalletSigner != null) {
+      if (adminSignerArgs.type !== existingWalletSigner.type) {
+        throw new WalletCreationError(
+          "The wallet signer type provided in the wallet config does not match the existing wallet's adminSigner type"
+        );
+      }
+      compareSignerConfigs(adminSignerArgs, existingWalletSigner);
+    }
+    if (args.delegatedSigners != null) {
+      this.validateDelegatedSigners(existingWallet, args.delegatedSigners);
+    }
+  }
+  validateDelegatedSigners(existingWallet, inputDelegatedSigners) {
+    var _a;
+    const existingDelegatedSigners = (_a = existingWallet == null ? void 0 : existingWallet.config) == null ? void 0 : _a.delegatedSigners;
+    if (inputDelegatedSigners.length === 0) {
+      return;
+    }
+    if (existingDelegatedSigners == null || existingDelegatedSigners.length === 0) {
+      throw new WalletCreationError(
+        `${inputDelegatedSigners.length} delegated signer(s) specified, but wallet "${existingWallet.address}" has no delegated signers. ${DELEGATED_SIGNER_MISMATCH_ERROR}`
+      );
+    }
+    for (const argSigner of inputDelegatedSigners) {
+      const matchingExistingSigner = existingDelegatedSigners.find(
+        (existingSigner) => existingSigner.locator === argSigner.signer
+      );
+      if (matchingExistingSigner == null) {
+        const walletSigners = existingDelegatedSigners.map((s) => s.locator).join(", ");
+        throw new WalletCreationError(
+          `Delegated signer '${argSigner.signer}' does not exist in wallet "${existingWallet.address}". Available delegated signers: ${walletSigners}. ${DELEGATED_SIGNER_MISMATCH_ERROR}`
+        );
+      }
+    }
+  }
+  getChainType(chain) {
+    if (chain === "solana") {
+      return "solana";
+    }
+    if (chain === "stellar") {
+      return "stellar";
+    }
+    return "evm";
+  }
+};
+
+export {
+  WalletFactory
+};

package/dist/chunk-SGINWAB6.js

@@ -0,0 +1,155 @@
+// src/utils/errors.ts
+import { CrossmintSDKError, WalletErrorCode } from "@crossmint/common-sdk-base";
+var InvalidApiKeyError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.API_KEY_INVALID, details);
+  }
+};
+var InvalidEnvironmentError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.ENVIRONMENT_INVALID, details);
+  }
+};
+var WalletTypeNotSupportedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.WALLET_TYPE_INVALID, details);
+  }
+};
+var WalletNotAvailableError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.WALLET_NOT_AVAILABLE, details);
+  }
+};
+var InvalidWalletConfigError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.WALLET_NOT_AVAILABLE, details);
+  }
+};
+var WalletCreationError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.WALLET_CREATION_FAILED, details);
+  }
+};
+var WalletTypeMismatchError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.WALLET_TYPE_INVALID, details);
+  }
+};
+var SignerTypeMismatchError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.SIGNER_INVALID, details);
+  }
+};
+var InvalidSignerError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.SIGNER_INVALID, details);
+  }
+};
+var InvalidMessageFormatError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.MESSAGE_INVALID, details);
+  }
+};
+var InvalidTypedDataError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.MESSAGE_INVALID, details);
+  }
+};
+var SignatureNotFoundError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.SIGNING_FAILED, details);
+  }
+};
+var SigningFailedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.SIGNING_FAILED, details);
+  }
+};
+var MessageSigningNotSupportedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.SIGNING_FAILED, details);
+  }
+};
+var SignatureNotCreatedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.NO_SIGNATURE, details);
+  }
+};
+var SignatureNotAvailableError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.NO_SIGNATURE, details);
+  }
+};
+var SignatureFailedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.SIGNING_FAILED, details);
+  }
+};
+var TransactionNotCreatedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.NO_TRANSACTION, details);
+  }
+};
+var TransactionNotAvailableError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.NO_TRANSACTION, details);
+  }
+};
+var TransactionConfirmationTimeoutError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.TRANSACTION_FAILED, details);
+  }
+};
+var TransactionSendingFailedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.TRANSACTION_FAILED, details);
+  }
+};
+var TransactionAwaitingApprovalError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.TRANSACTION_FAILED, details);
+  }
+};
+var TransactionHashNotFoundError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.TRANSACTION_FAILED, details);
+  }
+};
+var TransactionFailedError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.TRANSACTION_FAILED, details);
+  }
+};
+var PendingApprovalsError = class extends CrossmintSDKError {
+  constructor(message, details) {
+    super(message, WalletErrorCode.TRANSACTION_FAILED, details);
+  }
+};
+
+export {
+  InvalidApiKeyError,
+  InvalidEnvironmentError,
+  WalletTypeNotSupportedError,
+  WalletNotAvailableError,
+  InvalidWalletConfigError,
+  WalletCreationError,
+  WalletTypeMismatchError,
+  SignerTypeMismatchError,
+  InvalidSignerError,
+  InvalidMessageFormatError,
+  InvalidTypedDataError,
+  SignatureNotFoundError,
+  SigningFailedError,
+  MessageSigningNotSupportedError,
+  SignatureNotCreatedError,
+  SignatureNotAvailableError,
+  SignatureFailedError,
+  TransactionNotCreatedError,
+  TransactionNotAvailableError,
+  TransactionConfirmationTimeoutError,
+  TransactionSendingFailedError,
+  TransactionAwaitingApprovalError,
+  TransactionHashNotFoundError,
+  TransactionFailedError,
+  PendingApprovalsError
+};

package/dist/chunk-TK3EUCQ4.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/non-custodial/ncs-iframe-manager.ts
+var _clientsdkwindow = require('@crossmint/client-sdk-window');
+var _clientsigners = require('@crossmint/client-signers');
+var NcsIframeManager = class {
+  constructor(config) {
+    this.config = config;
+    this.handshakeParent = null;
+  }
+  initialize() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      if (this.handshakeParent) {
+        return this.handshakeParent;
+      }
+      const iframeUrl = new URL(_clientsigners.environmentUrlConfig[this.config.environment]);
+      iframeUrl.searchParams.set("targetOrigin", window.location.origin);
+      const iframeElement = yield this.createInvisibleIFrame(iframeUrl.toString());
+      this.handshakeParent = yield _clientsdkwindow.IFrameWindow.init(
+        iframeElement,
+        {
+          targetOrigin: iframeUrl.origin,
+          incomingEvents: _clientsigners.signerOutboundEvents,
+          outgoingEvents: _clientsigners.signerInboundEvents
+        },
+        _clientsdkwindow.SignersWindowTransport
+      );
+      yield this.handshakeParent.handshakeWithChild();
+      return this.handshakeParent;
+    });
+  }
+  createInvisibleIFrame(url) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      const iframe = document.createElement("iframe");
+      iframe.src = url;
+      Object.assign(iframe.style, {
+        position: "absolute",
+        opacity: "0",
+        pointerEvents: "none",
+        width: "0",
+        height: "0",
+        border: "none",
+        top: "-9999px",
+        left: "-9999px"
+      });
+      return new Promise((resolve, reject) => {
+        iframe.onload = () => resolve(iframe);
+        iframe.onerror = () => reject(new Error("Failed to load iframe content"));
+        document.body.appendChild(iframe);
+      });
+    });
+  }
+};
+
+
+
+exports.NcsIframeManager = NcsIframeManager;

package/dist/chunk-TOHXQVLS.js

@@ -0,0 +1,58 @@
+import {
+  EVMNonCustodialSigner
+} from "./chunk-454RYNSZ.js";
+import {
+  SolanaNonCustodialSigner
+} from "./chunk-XRA5GFH3.js";
+import {
+  StellarNonCustodialSigner
+} from "./chunk-K3HFAPSV.js";
+import {
+  EVMApiKeySigner
+} from "./chunk-AL77JANE.js";
+import {
+  EVMExternalWalletSigner
+} from "./chunk-MZBFXUHT.js";
+import {
+  PasskeySigner
+} from "./chunk-EYJQSDDI.js";
+import {
+  SolanaApiKeySigner
+} from "./chunk-ZTGRDOOH.js";
+import {
+  SolanaExternalWalletSigner
+} from "./chunk-DQCXGBZM.js";
+import {
+  StellarExternalWalletSigner
+} from "./chunk-WC7T2CR4.js";
+
+// src/signers/index.ts
+function assembleSigner(chain, config) {
+  switch (config.type) {
+    case "email":
+    case "phone":
+      if (chain === "solana") {
+        return new SolanaNonCustodialSigner(config);
+      }
+      if (chain === "stellar") {
+        return new StellarNonCustodialSigner(config);
+      }
+      return new EVMNonCustodialSigner(config);
+    case "api-key":
+      return chain === "solana" ? new SolanaApiKeySigner(config) : new EVMApiKeySigner(config);
+    case "external-wallet":
+      if (chain === "solana") {
+        return new SolanaExternalWalletSigner(config);
+      }
+      if (chain === "stellar") {
+        return new StellarExternalWalletSigner(config);
+      }
+      return new EVMExternalWalletSigner(config);
+    case "passkey":
+      return new PasskeySigner(config);
+  }
+}
+
+export {
+  assembleSigner
+};