@crossmint/wallets-sdk 0.18.2 → 0.18.4

package/dist/chunk-CHGPNMRL.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/evm-api-key.ts
+var EVMApiKeySigner = class {
+  constructor(config) {
+    this.config = config;
+    this.type = "api-key";
+  }
+  locator() {
+    return this.config.locator;
+  }
+  signMessage() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield Promise.reject(
+        new Error(
+          "API key signers do not support direct message signing - signatures are handled automatically by the backend"
+        )
+      );
+    });
+  }
+  signTransaction() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield Promise.reject(
+        new Error(
+          "API key signers do not support direct transaction signing - transaction are handled automatically by the backend"
+        )
+      );
+    });
+  }
+};
+
+
+
+exports.EVMApiKeySigner = EVMApiKeySigner;

package/dist/chunk-CN2GVFBU.cjs

@@ -0,0 +1,138 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkNIBKCMQ2cjs = require('./chunk-NIBKCMQ2.cjs');
+
+
+var _chunk55V4VMTXcjs = require('./chunk-55V4VMTX.cjs');
+
+// src/chains/chains.ts
+var _commonsdkbase = require('@crossmint/common-sdk-base');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chains = require('viem/chains');
+var TESTNET_AA_CHAINS = [
+  _commonsdkbase.BlockchainIncludingTestnet.ABSTRACT_TESTNET,
+  _commonsdkbase.BlockchainIncludingTestnet.ARBITRUM_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.BASE_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.CURTIS,
+  _commonsdkbase.BlockchainIncludingTestnet.ETHEREUM_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.FLOW_TESTNET,
+  _commonsdkbase.BlockchainIncludingTestnet.MANTLE_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.MODE_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.OPTIMISM_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.PLUME_TESTNET,
+  _commonsdkbase.BlockchainIncludingTestnet.POLYGON_AMOY,
+  _commonsdkbase.BlockchainIncludingTestnet.SCROLL_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.SEI_ATLANTIC_2_TESTNET,
+  _commonsdkbase.BlockchainIncludingTestnet.STORY_TESTNET,
+  _commonsdkbase.BlockchainIncludingTestnet.WORLD_CHAIN_SEPOLIA,
+  _commonsdkbase.BlockchainIncludingTestnet.ZORA_SEPOLIA
+];
+var PRODUCTION_AA_CHAINS = [
+  _commonsdkbase.BlockchainIncludingTestnet.ABSTRACT,
+  _commonsdkbase.BlockchainIncludingTestnet.APECHAIN,
+  _commonsdkbase.BlockchainIncludingTestnet.ARBITRUM,
+  _commonsdkbase.BlockchainIncludingTestnet.ARBITRUMNOVA,
+  _commonsdkbase.BlockchainIncludingTestnet.BASE,
+  _commonsdkbase.BlockchainIncludingTestnet.BSC,
+  _commonsdkbase.BlockchainIncludingTestnet.FLOW,
+  _commonsdkbase.BlockchainIncludingTestnet.MANTLE,
+  _commonsdkbase.BlockchainIncludingTestnet.MODE,
+  _commonsdkbase.BlockchainIncludingTestnet.OPTIMISM,
+  _commonsdkbase.BlockchainIncludingTestnet.PLUME,
+  _commonsdkbase.BlockchainIncludingTestnet.POLYGON,
+  _commonsdkbase.BlockchainIncludingTestnet.SCROLL,
+  _commonsdkbase.BlockchainIncludingTestnet.SEI_PACIFIC_1,
+  _commonsdkbase.BlockchainIncludingTestnet.SHAPE,
+  _commonsdkbase.BlockchainIncludingTestnet.STORY,
+  _commonsdkbase.BlockchainIncludingTestnet.WORLDCHAIN,
+  _commonsdkbase.BlockchainIncludingTestnet.ZORA
+];
+function toViemChain(chain) {
+  switch (chain) {
+    case _commonsdkbase.BlockchainIncludingTestnet.BASE_SEPOLIA:
+      return _chains.baseSepolia;
+    case _commonsdkbase.BlockchainIncludingTestnet.BASE:
+      return _chains.base;
+    case _commonsdkbase.BlockchainIncludingTestnet.POLYGON_AMOY:
+      return _chains.polygonAmoy;
+    case _commonsdkbase.BlockchainIncludingTestnet.POLYGON:
+      return _chains.polygon;
+    case _commonsdkbase.BlockchainIncludingTestnet.OPTIMISM_SEPOLIA:
+      return _chains.optimismSepolia;
+    case _commonsdkbase.BlockchainIncludingTestnet.OPTIMISM:
+      return _chains.optimism;
+    case _commonsdkbase.BlockchainIncludingTestnet.ARBITRUM_SEPOLIA:
+      return _chains.arbitrumSepolia;
+    case _commonsdkbase.BlockchainIncludingTestnet.ARBITRUM:
+      return _chains.arbitrum;
+    case _commonsdkbase.BlockchainIncludingTestnet.ARBITRUMNOVA:
+      return _chains.arbitrumNova;
+    case _commonsdkbase.BlockchainIncludingTestnet.STORY_TESTNET:
+      return _chunk55V4VMTXcjs.storyTestnet;
+    case _commonsdkbase.BlockchainIncludingTestnet.STORY:
+      return _chunkNIBKCMQ2cjs.story;
+    case _commonsdkbase.BlockchainIncludingTestnet.MODE_SEPOLIA:
+      return _chains.modeTestnet;
+    case _commonsdkbase.BlockchainIncludingTestnet.MODE:
+      return _chains.mode;
+    case _commonsdkbase.BlockchainIncludingTestnet.BSC:
+      return _chains.bsc;
+    case _commonsdkbase.BlockchainIncludingTestnet.SHAPE:
+      return _chains.shape;
+    case _commonsdkbase.BlockchainIncludingTestnet.ZORA:
+      return _chains.zora;
+    case _commonsdkbase.BlockchainIncludingTestnet.ZORA_SEPOLIA:
+      return _chains.zoraSepolia;
+    case _commonsdkbase.BlockchainIncludingTestnet.ETHEREUM_SEPOLIA:
+      return _chains.sepolia;
+    case _commonsdkbase.BlockchainIncludingTestnet.FLOW:
+      return _chains.flowMainnet;
+    case _commonsdkbase.BlockchainIncludingTestnet.FLOW_TESTNET:
+      return _chains.flowTestnet;
+    case _commonsdkbase.BlockchainIncludingTestnet.PLUME_TESTNET:
+      return _chains.plumeTestnet;
+    case _commonsdkbase.BlockchainIncludingTestnet.PLUME:
+      return _chains.plume;
+    case _commonsdkbase.BlockchainIncludingTestnet.ABSTRACT:
+    case _commonsdkbase.BlockchainIncludingTestnet.ABSTRACT_TESTNET:
+    case _commonsdkbase.BlockchainIncludingTestnet.APECHAIN:
+    case _commonsdkbase.BlockchainIncludingTestnet.MANTLE:
+    case _commonsdkbase.BlockchainIncludingTestnet.MANTLE_SEPOLIA:
+    case _commonsdkbase.BlockchainIncludingTestnet.SCROLL:
+    case _commonsdkbase.BlockchainIncludingTestnet.SCROLL_SEPOLIA:
+    case _commonsdkbase.BlockchainIncludingTestnet.SEI_PACIFIC_1:
+    case _commonsdkbase.BlockchainIncludingTestnet.SEI_ATLANTIC_2_TESTNET:
+    case _commonsdkbase.BlockchainIncludingTestnet.CURTIS:
+    case _commonsdkbase.BlockchainIncludingTestnet.WORLDCHAIN:
+    case _commonsdkbase.BlockchainIncludingTestnet.WORLD_CHAIN_SEPOLIA:
+      throw new Error(
+        `Chain ${chain} is not yet supported in toViemChain function. Please add the appropriate viem chain definition.`
+      );
+    default:
+      throw new Error(`Unknown chain: ${chain}`);
+  }
+}
+
+
+
+exports.toViemChain = toViemChain;

package/dist/chunk-COVOGZ4S.js

@@ -0,0 +1,80 @@
+import {
+  DEFAULT_EVENT_OPTIONS,
+  NonCustodialSigner
+} from "./chunk-BAULM7A2.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/signers/non-custodial/ncs-evm-signer.ts
+import { PersonalMessage } from "ox";
+import { isHex, toHex } from "viem";
+var EVMNonCustodialSigner = class _EVMNonCustodialSigner extends NonCustodialSigner {
+  constructor(config) {
+    super(config);
+  }
+  signMessage(message) {
+    return __async(this, null, function* () {
+      const messageRaw = isHex(message) ? message : toHex(message);
+      const messageToSign = PersonalMessage.getSignPayload(messageRaw);
+      return yield this.sign(messageToSign);
+    });
+  }
+  signTransaction(transaction) {
+    return __async(this, null, function* () {
+      return yield this.sign(transaction);
+    });
+  }
+  sign(raw) {
+    return __async(this, null, function* () {
+      var _a;
+      yield this.handleAuthRequired();
+      const jwt = this.getJwtOrThrow();
+      const hexString = raw.replace("0x", "");
+      const res = yield (_a = this.config.clientTEEConnection) == null ? void 0 : _a.sendAction({
+        event: "request:sign",
+        responseEvent: "response:sign",
+        data: {
+          authData: {
+            jwt,
+            apiKey: this.config.crossmint.apiKey
+          },
+          data: {
+            keyType: "secp256k1",
+            bytes: hexString,
+            encoding: "hex"
+          }
+        },
+        options: DEFAULT_EVENT_OPTIONS
+      });
+      if ((res == null ? void 0 : res.status) === "error") {
+        throw new Error(res.error);
+      }
+      if ((res == null ? void 0 : res.signature) == null) {
+        throw new Error("Failed to sign transaction");
+      }
+      _EVMNonCustodialSigner.verifyPublicKeyFormat(res.publicKey);
+      return { signature: res.signature.bytes };
+    });
+  }
+  static verifyPublicKeyFormat(publicKey) {
+    if (publicKey == null) {
+      throw new Error("No public key found");
+    }
+    if (publicKey.encoding !== "hex" || publicKey.keyType !== "secp256k1" || publicKey.bytes == null) {
+      throw new Error(
+        "Not supported. Expected public key to be in hex encoding and secp256k1 key type. Got: " + JSON.stringify(publicKey)
+      );
+    }
+  }
+  getChainKeyParams() {
+    return {
+      scheme: "secp256k1",
+      encoding: "hex"
+    };
+  }
+};
+
+export {
+  EVMNonCustodialSigner
+};

package/dist/chunk-DPERJZBG.js

@@ -0,0 +1,63 @@
+import {
+  WalletFactory
+} from "./chunk-7QL5JVK4.js";
+import {
+  ApiClient
+} from "./chunk-5H5YHSCK.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/sdk.ts
+import { createCrossmint } from "@crossmint/common-sdk-base";
+var CrossmintWallets = class _CrossmintWallets {
+  constructor(crossmint) {
+    const apiClient = new ApiClient(crossmint);
+    this.walletFactory = new WalletFactory(apiClient);
+  }
+  /**
+   * Initialize the Wallets SDK
+   * @param crossmint - Crossmint data (use `createCrossmint` to initialize)
+   * @returns A new CrossmintWallets instance
+   */
+  static from(crossmint) {
+    return new _CrossmintWallets(crossmint);
+  }
+  /**
+   * Get or create a wallet, can only be called on the client side
+   * @param args - Wallet data
+   * @param options - Wallet options
+   * @returns An existing wallet or a new wallet
+   */
+  getOrCreateWallet(options) {
+    return __async(this, null, function* () {
+      return yield this.walletFactory.getOrCreateWallet(options);
+    });
+  }
+  /**
+   * Get an existing wallet by its locator, can only be called on the server side
+   * @param walletLocator - Wallet locator
+   * @param options - Wallet options
+   * @returns A wallet if found, throws WalletNotAvailableError if not found
+   */
+  getWallet(walletLocator, options) {
+    return __async(this, null, function* () {
+      return yield this.walletFactory.getWallet(walletLocator, options);
+    });
+  }
+  /**
+   * Create a new wallet, can only be called on the server side
+   * @param options - Wallet options
+   * @returns A new wallet
+   */
+  createWallet(options) {
+    return __async(this, null, function* () {
+      return yield this.walletFactory.createWallet(options);
+    });
+  }
+};
+
+export {
+  createCrossmint,
+  CrossmintWallets
+};

package/dist/chunk-DQCXGBZM.js

@@ -0,0 +1,59 @@
+import {
+  TransactionFailedError
+} from "./chunk-SGINWAB6.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/signers/solana-external-wallet.ts
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import base58 from "bs58";
+var SolanaExternalWalletSigner = class {
+  constructor(config) {
+    this.config = config;
+    this.type = "external-wallet";
+    if (config.address == null) {
+      throw new Error("Please provide an address for the External Wallet Signer");
+    }
+    this._address = config.address;
+    this.onSignTransaction = config.onSignTransaction;
+  }
+  address() {
+    return this._address;
+  }
+  locator() {
+    return this.config.locator;
+  }
+  signMessage() {
+    return __async(this, null, function* () {
+      return yield Promise.reject(new Error("signMessage method not implemented for solana external wallet signer"));
+    });
+  }
+  signTransaction(transaction) {
+    return __async(this, null, function* () {
+      if (this.onSignTransaction == null) {
+        return yield Promise.reject(
+          new Error("onSignTransaction method is required to sign transactions with a Solana external wallet")
+        );
+      }
+      const transactionBytes = base58.decode(transaction);
+      const deserializedTransaction = VersionedTransaction.deserialize(transactionBytes);
+      const signedTxn = yield this.onSignTransaction(deserializedTransaction);
+      const externalWalletPublicKey = new PublicKey(this._address);
+      const signerIndex = signedTxn.message.staticAccountKeys.findIndex((key) => key.equals(externalWalletPublicKey));
+      if (signerIndex === -1) {
+        throw new TransactionFailedError("Wallet public key not found in transaction signers");
+      }
+      const validSignature = signedTxn.signatures[signerIndex];
+      if (validSignature == null) {
+        throw new TransactionFailedError("No valid signature found in the transaction");
+      }
+      const signatureBytes = new Uint8Array(Object.values(validSignature));
+      return { signature: base58.encode(signatureBytes) };
+    });
+  }
+};
+
+export {
+  SolanaExternalWalletSigner
+};

package/dist/chunk-E4LJ7252.cjs

@@ -0,0 +1,289 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTK3EUCQ4cjs = require('./chunk-TK3EUCQ4.cjs');
+
+
+var _chunkRHR6P2KPcjs = require('./chunk-RHR6P2KP.cjs');
+
+
+
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/non-custodial/ncs-signer.ts
+var _commonsdkbase = require('@crossmint/common-sdk-base');
+var NonCustodialSigner = class {
+  constructor(config) {
+    this.config = config;
+    this._needsAuth = true;
+    this._authPromise = null;
+    this._initializationPromise = null;
+    if (typeof window !== "undefined") {
+      this.initialize();
+    }
+    this.type = this.config.type;
+  }
+  locator() {
+    return this.config.locator;
+  }
+  address() {
+    return this.config.address;
+  }
+  initialize() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      if (this.config.clientTEEConnection == null) {
+        const parsedAPIKey = _commonsdkbase.validateAPIKey.call(void 0, this.config.crossmint.apiKey);
+        if (!parsedAPIKey.isValid) {
+          throw new Error("Invalid API key");
+        }
+        const iframeManager = new (0, _chunkTK3EUCQ4cjs.NcsIframeManager)({ environment: parsedAPIKey.environment });
+        this.config.clientTEEConnection = yield iframeManager.initialize();
+      }
+    });
+  }
+  getTEEConnection() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      if (this.config.clientTEEConnection == null) {
+        if (this._initializationPromise) {
+          yield this._initializationPromise;
+          return this.config.clientTEEConnection;
+        }
+        this._initializationPromise = this.initializeTEEConnection();
+        try {
+          yield this._initializationPromise;
+        } finally {
+          this._initializationPromise = null;
+        }
+      }
+      return this.config.clientTEEConnection;
+    });
+  }
+  initializeTEEConnection() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      console.warn("TEE connection is not initialized, initializing now...");
+      const parsedAPIKey = _commonsdkbase.validateAPIKey.call(void 0, this.config.crossmint.apiKey);
+      if (!parsedAPIKey.isValid) {
+        throw new Error("Invalid API key");
+      }
+      const iframeManager = new (0, _chunkTK3EUCQ4cjs.NcsIframeManager)({ environment: parsedAPIKey.environment });
+      this.config.clientTEEConnection = yield iframeManager.initialize();
+      if (this.config.clientTEEConnection == null) {
+        throw new Error("Failed to initialize TEE connection");
+      }
+      console.log("TEE connection initialized successfully");
+    });
+  }
+  handleAuthRequired() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      var _a, _b;
+      const clientTEEConnection = yield this.getTEEConnection();
+      if (this.config.onAuthRequired == null) {
+        throw new Error(
+          `${this.type} signer requires the onAuthRequired callback to handle OTP verification. This callback manages the authentication flow (sending OTP and verifying user input). If using our React/React Native SDK, this is handled automatically by the provider. For other environments, implement: onAuthRequired: (needsAuth, sendEmailWithOtp, verifyOtp, reject) => { /* your UI logic */ }`
+        );
+      }
+      const signerResponse = yield clientTEEConnection.sendAction({
+        event: "request:get-status",
+        responseEvent: "response:get-status",
+        data: {
+          authData: {
+            jwt: (_b = (_a = this.config.crossmint.experimental_customAuth) == null ? void 0 : _a.jwt) != null ? _b : "",
+            apiKey: this.config.crossmint.apiKey
+          }
+        },
+        options: _chunkG5NYLGM5cjs.__spreadProps.call(void 0, _chunkG5NYLGM5cjs.__spreadValues.call(void 0, {}, DEFAULT_EVENT_OPTIONS), {
+          maxRetries: 5
+        })
+      });
+      if ((signerResponse == null ? void 0 : signerResponse.status) !== "success") {
+        throw new Error(signerResponse == null ? void 0 : signerResponse.error);
+      }
+      if (signerResponse.signerStatus === "ready") {
+        this._needsAuth = false;
+        return;
+      } else {
+        this._needsAuth = true;
+      }
+      const { promise, resolve, reject } = this.createAuthPromise();
+      this._authPromise = { promise, resolve, reject };
+      if (this.config.onAuthRequired) {
+        try {
+          yield this.config.onAuthRequired(
+            this._needsAuth,
+            () => this.sendMessageWithOtp(),
+            (otp) => this.verifyOtp(otp),
+            () => _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+              this._needsAuth = false;
+              if (this.config.onAuthRequired != null) {
+                yield this.config.onAuthRequired(
+                  this._needsAuth,
+                  () => this.sendMessageWithOtp(),
+                  (otp) => this.verifyOtp(otp),
+                  () => {
+                    var _a2;
+                    return (_a2 = this._authPromise) == null ? void 0 : _a2.reject(new (0, _chunkRHR6P2KPcjs.AuthRejectedError)());
+                  }
+                );
+              }
+              reject(new (0, _chunkRHR6P2KPcjs.AuthRejectedError)());
+            })
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }
+      try {
+        yield promise;
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  ensureAuthenticated() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      yield this.handleAuthRequired();
+    });
+  }
+  getJwtOrThrow() {
+    var _a;
+    const jwt = (_a = this.config.crossmint.experimental_customAuth) == null ? void 0 : _a.jwt;
+    if (jwt == null) {
+      throw new Error("JWT is required");
+    }
+    return jwt;
+  }
+  createAuthPromise() {
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    return { promise, resolve: resolvePromise, reject: rejectPromise };
+  }
+  sendMessageWithOtp() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      var _a, _b, _c;
+      const handshakeParent = yield this.getTEEConnection();
+      const authId = this.getAuthId();
+      const response = yield handshakeParent.sendAction({
+        event: "request:start-onboarding",
+        responseEvent: "response:start-onboarding",
+        data: {
+          authData: {
+            jwt: (_b = (_a = this.config.crossmint.experimental_customAuth) == null ? void 0 : _a.jwt) != null ? _b : "",
+            apiKey: this.config.crossmint.apiKey
+          },
+          data: { authId }
+        },
+        options: _chunkG5NYLGM5cjs.__spreadProps.call(void 0, _chunkG5NYLGM5cjs.__spreadValues.call(void 0, {}, DEFAULT_EVENT_OPTIONS), {
+          maxRetries: 3
+        })
+      });
+      if ((response == null ? void 0 : response.status) === "success" && response.signerStatus === "ready") {
+        this._needsAuth = false;
+        return;
+      }
+      if ((response == null ? void 0 : response.status) === "error") {
+        console.error("[sendMessageWithOtp] Failed to send OTP:", response);
+        (_c = this._authPromise) == null ? void 0 : _c.reject(new Error(response.error || "Failed to initiate OTP process."));
+      }
+    });
+  }
+  getAuthId() {
+    if (this.config.type === "email") {
+      return `email:${this.config.email}`;
+    }
+    return `phone:${this.config.phone}`;
+  }
+  verifyOtp(encryptedOtp) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      let response;
+      try {
+        const handshakeParent = yield this.getTEEConnection();
+        response = yield handshakeParent.sendAction({
+          event: "request:complete-onboarding",
+          responseEvent: "response:complete-onboarding",
+          data: {
+            authData: {
+              jwt: (_b = (_a = this.config.crossmint.experimental_customAuth) == null ? void 0 : _a.jwt) != null ? _b : "",
+              apiKey: this.config.crossmint.apiKey
+            },
+            data: {
+              onboardingAuthentication: { encryptedOtp }
+            }
+          },
+          options: _chunkG5NYLGM5cjs.__spreadProps.call(void 0, _chunkG5NYLGM5cjs.__spreadValues.call(void 0, {}, DEFAULT_EVENT_OPTIONS), {
+            maxRetries: 3
+          })
+        });
+      } catch (err) {
+        console.error("[verifyOtp] Error sending OTP validation request:", err);
+        this._needsAuth = true;
+        (_c = this._authPromise) == null ? void 0 : _c.reject(err);
+        throw err;
+      }
+      if ((response == null ? void 0 : response.status) === "success") {
+        this._needsAuth = false;
+        if (this.config.onAuthRequired != null) {
+          yield this.config.onAuthRequired(
+            this._needsAuth,
+            () => this.sendMessageWithOtp(),
+            (otp) => this.verifyOtp(otp),
+            () => {
+              var _a2;
+              return (_a2 = this._authPromise) == null ? void 0 : _a2.reject(new (0, _chunkRHR6P2KPcjs.AuthRejectedError)());
+            }
+          );
+        }
+        (_d = this._authPromise) == null ? void 0 : _d.resolve();
+        return;
+      }
+      console.error("[verifyOtp] Failed to validate OTP:", response);
+      this._needsAuth = true;
+      const errorMessage = (response == null ? void 0 : response.status) === "error" ? response.error : "Failed to validate encrypted OTP";
+      const error = new Error(errorMessage);
+      (_e = this._authPromise) == null ? void 0 : _e.reject(error);
+      throw error;
+    });
+  }
+  /**
+   * Export the private key for this signer
+   * @throws {Error} If signer is not authenticated
+   */
+  _exportPrivateKey(exportTEEConnection) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      yield this.handleAuthRequired();
+      const jwt = this.getJwtOrThrow();
+      const { scheme, encoding } = this.getChainKeyParams();
+      const response = yield exportTEEConnection.sendAction({
+        event: "request:export-signer",
+        responseEvent: "response:export-signer",
+        data: {
+          authData: {
+            jwt,
+            apiKey: this.config.crossmint.apiKey
+          },
+          data: {
+            scheme,
+            encoding
+          }
+        },
+        options: DEFAULT_EVENT_OPTIONS
+      });
+      if ((response == null ? void 0 : response.status) === "error") {
+        throw new Error(response.error || "Failed to export private key");
+      }
+    });
+  }
+};
+var DEFAULT_EVENT_OPTIONS = {
+  timeoutMs: 1e4,
+  intervalMs: 5e3
+};
+
+
+
+
+exports.NonCustodialSigner = NonCustodialSigner; exports.DEFAULT_EVENT_OPTIONS = DEFAULT_EVENT_OPTIONS;