@crossmint/wallets-sdk 0.18.3 → 0.18.6

package/dist/chunk-6G7ZWCCG.js

@@ -0,0 +1,247 @@
+import {
+  InvalidApiKeyError
+} from "./chunk-SGINWAB6.js";
+import {
+  walletsLogger
+} from "./chunk-RAWKXOHR.js";
+import {
+  SDK_NAME,
+  SDK_VERSION
+} from "./chunk-WQVJM3PG.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/api/client.ts
+import {
+  APIKeyEnvironmentPrefix,
+  APIKeyUsageOrigin,
+  CrossmintApiClient
+} from "@crossmint/common-sdk-base";
+var ApiClient = class extends CrossmintApiClient {
+  constructor(crossmint) {
+    super(crossmint, {
+      internalConfig: {
+        sdkMetadata: { name: SDK_NAME, version: SDK_VERSION }
+      }
+    });
+    this.apiPrefix = "api/2025-06-09/wallets";
+    this.legacyApiPrefix = "api/2022-06-09/wallets";
+  }
+  createWallet(params) {
+    return __async(this, null, function* () {
+      const path = this.isServerSide ? `${this.apiPrefix}` : `${this.apiPrefix}/me`;
+      walletsLogger.info("wallets.api.createWallet", {
+        chainType: params.chainType,
+        walletType: params.type
+      });
+      const response = yield this.post(path, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      const result = yield response.json();
+      if ("error" in result) {
+        walletsLogger.error("wallets.api.createWallet.error", {
+          error: result.error,
+          chainType: params.chainType
+        });
+      } else if ("address" in result) {
+        walletsLogger.info("wallets.api.createWallet.success", {
+          address: result.address,
+          chainType: params.chainType
+        });
+      }
+      return result;
+    });
+  }
+  getWallet(locator) {
+    return __async(this, null, function* () {
+      walletsLogger.info("wallets.api.getWallet", { locator });
+      const response = yield this.get(`${this.apiPrefix}/${locator}`, {
+        headers: this.headers
+      });
+      const result = yield response.json();
+      if ("error" in result) {
+        walletsLogger.warn("wallets.api.getWallet.error", {
+          locator,
+          error: result.error
+        });
+      } else if ("address" in result) {
+        walletsLogger.info("wallets.api.getWallet.success", result);
+      }
+      return result;
+    });
+  }
+  createTransaction(walletLocator, params) {
+    return __async(this, null, function* () {
+      const response = yield this.post(`${this.apiPrefix}/${walletLocator}/transactions`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  approveTransaction(walletLocator, transactionId, params) {
+    return __async(this, null, function* () {
+      const response = yield this.post(`${this.apiPrefix}/${walletLocator}/transactions/${transactionId}/approvals`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  getTransaction(walletLocator, transactionId) {
+    return __async(this, null, function* () {
+      const response = yield this.get(`${this.apiPrefix}/${walletLocator}/transactions/${transactionId}`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  createSignature(walletLocator, params) {
+    return __async(this, null, function* () {
+      const response = yield this.post(`${this.apiPrefix}/${walletLocator}/signatures`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  approveSignature(walletLocator, signatureId, params) {
+    return __async(this, null, function* () {
+      const response = yield this.post(`${this.apiPrefix}/${walletLocator}/signatures/${signatureId}/approvals`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  getSignature(walletLocator, signatureId) {
+    return __async(this, null, function* () {
+      const response = yield this.get(`${this.apiPrefix}/${walletLocator}/signatures/${signatureId}`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  getTransactions(walletLocator) {
+    return __async(this, null, function* () {
+      const response = yield this.get(`${this.apiPrefix}/${walletLocator}/transactions`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  experimental_getNfts(params) {
+    return __async(this, null, function* () {
+      const queryParams = new URLSearchParams();
+      queryParams.append("page", params.page.toString());
+      queryParams.append("perPage", params.perPage.toString());
+      const identifier = `${params.chain}:${params.address}`;
+      const response = yield this.get(`${this.apiPrefix}/${identifier}/nfts?${queryParams.toString()}`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  experimental_activity(walletLocator, params) {
+    return __async(this, null, function* () {
+      let legacyLocator = walletLocator;
+      if (!this.isServerSide) {
+        legacyLocator = `me:${params.chain === "solana" ? "solana-smart-wallet" : "evm-smart-wallet"}`;
+      }
+      const queryParams = new URLSearchParams();
+      queryParams.append("chain", params.chain.toString());
+      const response = yield this.get(`${this.legacyApiPrefix}/${legacyLocator}/activity?${queryParams.toString()}`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  getBalance(walletLocator, params) {
+    return __async(this, null, function* () {
+      const queryParams = new URLSearchParams();
+      queryParams.append("tokens", params.tokens.join(","));
+      queryParams.append("chains", params.chains.join(","));
+      const response = yield this.get(`${this.apiPrefix}/${walletLocator}/balances?${queryParams.toString()}`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  fundWallet(walletLocator, params) {
+    return __async(this, null, function* () {
+      if (this.environment === APIKeyEnvironmentPrefix.PRODUCTION) {
+        throw new Error("Funding wallets is only supported in staging environment");
+      }
+      const response = yield this.post(`api/v1-alpha2/wallets/${walletLocator}/balances`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  registerSigner(walletLocator, params) {
+    return __async(this, null, function* () {
+      const response = yield this.post(`${this.apiPrefix}/${walletLocator}/signers`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  getSigner(walletLocator, signer) {
+    return __async(this, null, function* () {
+      const response = yield this.get(`${this.apiPrefix}/${walletLocator}/signers/${signer}`, {
+        headers: this.headers
+      });
+      return response.json();
+    });
+  }
+  send(walletLocator, tokenLocator, params) {
+    return __async(this, null, function* () {
+      walletsLogger.info("wallets.api.send", {
+        walletLocator,
+        tokenLocator,
+        recipient: params.recipient
+      });
+      const response = yield this.post(`${this.apiPrefix}/${walletLocator}/tokens/${tokenLocator}/transfers`, {
+        body: JSON.stringify(params),
+        headers: this.headers
+      });
+      const result = yield response.json();
+      if ("error" in result) {
+        walletsLogger.error("wallets.api.send.error", {
+          walletLocator,
+          tokenLocator,
+          error: result.error
+        });
+      } else if ("id" in result) {
+        walletsLogger.info("wallets.api.send.success", {
+          walletLocator,
+          transactionId: result.id
+        });
+      }
+      return result;
+    });
+  }
+  get isServerSide() {
+    return this.parsedAPIKey.usageOrigin === APIKeyUsageOrigin.SERVER;
+  }
+  get environment() {
+    if (!this.parsedAPIKey.isValid) {
+      throw new InvalidApiKeyError("Invalid API key");
+    }
+    return this.parsedAPIKey.environment;
+  }
+  get headers() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    return headers;
+  }
+};
+
+export {
+  ApiClient
+};

package/dist/chunk-7ECQJFYM.cjs

@@ -0,0 +1,63 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/evm-external-wallet.ts
+var EVMExternalWalletSigner = 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.provider = config.provider;
+    this.viemAccount = config.viemAccount;
+  }
+  address() {
+    return this._address;
+  }
+  locator() {
+    return this.config.locator;
+  }
+  signMessage(message) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      var _a;
+      if (this.provider != null) {
+        const signature = yield this.provider.request({
+          method: "personal_sign",
+          params: [message, this._address]
+        });
+        if (signature == null) {
+          throw new Error(
+            "[EVMExternalWalletSigner] Failed to sign message: EIP1193 provider signMessage returned null"
+          );
+        }
+        return { signature };
+      }
+      if (((_a = this.viemAccount) == null ? void 0 : _a.signMessage) != null) {
+        const signature = yield this.viemAccount.signMessage({
+          message: {
+            raw: message
+          }
+        });
+        if (signature == null) {
+          throw new Error(
+            "[EVMExternalWalletSigner] Failed to sign message: Viem account signMessage returned null"
+          );
+        }
+        return { signature };
+      }
+      throw new Error("No signer provider or viem account provided");
+    });
+  }
+  signTransaction(transaction) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield this.signMessage(transaction);
+    });
+  }
+};
+
+
+
+exports.EVMExternalWalletSigner = EVMExternalWalletSigner;

package/dist/chunk-7JFVG4IY.js

@@ -0,0 +1,59 @@
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/signers/non-custodial/ncs-iframe-manager.ts
+import { IFrameWindow, SignersWindowTransport } from "@crossmint/client-sdk-window";
+import { environmentUrlConfig, signerInboundEvents, signerOutboundEvents } from "@crossmint/client-signers";
+var NcsIframeManager = class {
+  constructor(config) {
+    this.config = config;
+    this.handshakeParent = null;
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      if (this.handshakeParent) {
+        return this.handshakeParent;
+      }
+      const iframeUrl = new URL(environmentUrlConfig[this.config.environment]);
+      iframeUrl.searchParams.set("targetOrigin", window.location.origin);
+      const iframeElement = yield this.createInvisibleIFrame(iframeUrl.toString());
+      this.handshakeParent = yield IFrameWindow.init(
+        iframeElement,
+        {
+          targetOrigin: iframeUrl.origin,
+          incomingEvents: signerOutboundEvents,
+          outgoingEvents: signerInboundEvents
+        },
+        SignersWindowTransport
+      );
+      yield this.handshakeParent.handshakeWithChild();
+      return this.handshakeParent;
+    });
+  }
+  createInvisibleIFrame(url) {
+    return __async(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);
+      });
+    });
+  }
+};
+
+export {
+  NcsIframeManager
+};

package/dist/chunk-AL77JANE.js

@@ -0,0 +1,36 @@
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// 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 __async(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 __async(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"
+        )
+      );
+    });
+  }
+};
+
+export {
+  EVMApiKeySigner
+};

package/dist/chunk-B6JOIWRH.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:", JSON.stringify(response, null, 2));
+      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;