@crossmint/wallets-sdk 0.18.2 → 0.18.4

package/dist/chunk-AJCWEEWH.js

@@ -0,0 +1,73 @@
+import {
+  DEFAULT_EVENT_OPTIONS,
+  NonCustodialSigner
+} from "./chunk-BAULM7A2.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/signers/non-custodial/ncs-stellar-signer.ts
+var StellarNonCustodialSigner = class _StellarNonCustodialSigner extends NonCustodialSigner {
+  constructor(config) {
+    super(config);
+  }
+  signMessage() {
+    return __async(this, null, function* () {
+      return yield Promise.reject(new Error("signMessage method not implemented for stellar signer"));
+    });
+  }
+  signTransaction(payload) {
+    return __async(this, null, function* () {
+      var _a;
+      yield this.handleAuthRequired();
+      const jwt = this.getJwtOrThrow();
+      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: "ed25519",
+            bytes: payload,
+            encoding: "base64"
+          }
+        },
+        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");
+      }
+      _StellarNonCustodialSigner.verifyPublicKeyFormat(res.publicKey);
+      if (res.signature.encoding !== "base64") {
+        throw new Error("Wrong encoding for signature. Expected base64, got " + res.signature.encoding);
+      }
+      return { signature: res.signature.bytes };
+    });
+  }
+  static verifyPublicKeyFormat(publicKey) {
+    if (publicKey == null) {
+      throw new Error("No public key found");
+    }
+    if (publicKey.encoding !== "base64" || publicKey.keyType !== "ed25519" || publicKey.bytes == null) {
+      throw new Error(
+        "Not supported. Expected public key to be in base64 encoding and ed25519 key type. Got: " + JSON.stringify(publicKey)
+      );
+    }
+  }
+  getChainKeyParams() {
+    return {
+      scheme: "ed25519",
+      encoding: "strkey"
+    };
+  }
+};
+
+export {
+  StellarNonCustodialSigner
+};

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-BAHU3KZE.cjs

@@ -0,0 +1,75 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+var _chunkE4LJ7252cjs = require('./chunk-E4LJ7252.cjs');
+
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/non-custodial/ncs-solana-signer.ts
+var _web3js = require('@solana/web3.js');
+var _bs58 = require('bs58'); var _bs582 = _interopRequireDefault(_bs58);
+var SolanaNonCustodialSigner = class _SolanaNonCustodialSigner extends _chunkE4LJ7252cjs.NonCustodialSigner {
+  constructor(config) {
+    super(config);
+  }
+  signMessage() {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield Promise.reject(new Error("signMessage method not implemented for email signer"));
+    });
+  }
+  signTransaction(transaction) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      var _a;
+      yield this.handleAuthRequired();
+      const jwt = this.getJwtOrThrow();
+      const transactionBytes = _bs582.default.decode(transaction);
+      const deserializedTransaction = _web3js.VersionedTransaction.deserialize(transactionBytes);
+      const messageData = deserializedTransaction.message.serialize();
+      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: "ed25519",
+            bytes: _bs582.default.encode(messageData),
+            encoding: "base58"
+          }
+        },
+        options: _chunkE4LJ7252cjs.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");
+      }
+      _SolanaNonCustodialSigner.verifyPublicKeyFormat(res.publicKey);
+      return { signature: res.signature.bytes };
+    });
+  }
+  static verifyPublicKeyFormat(publicKey) {
+    if (publicKey == null) {
+      throw new Error("No public key found");
+    }
+    if (publicKey.encoding !== "base58" || publicKey.keyType !== "ed25519" || publicKey.bytes == null) {
+      throw new Error(
+        "Not supported. Expected public key to be in base58 encoding and ed25519 key type. Got: " + JSON.stringify(publicKey)
+      );
+    }
+  }
+  getChainKeyParams() {
+    return {
+      scheme: "ed25519",
+      encoding: "base58"
+    };
+  }
+};
+
+
+
+exports.SolanaNonCustodialSigner = SolanaNonCustodialSigner;

package/dist/chunk-BAULM7A2.js

@@ -0,0 +1,289 @@
+import {
+  NcsIframeManager
+} from "./chunk-7JFVG4IY.js";
+import {
+  AuthRejectedError
+} from "./chunk-WJUPOCKJ.js";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-FPMW7Q5O.js";
+
+// src/signers/non-custodial/ncs-signer.ts
+import { validateAPIKey } from "@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 __async(this, null, function* () {
+      if (this.config.clientTEEConnection == null) {
+        const parsedAPIKey = validateAPIKey(this.config.crossmint.apiKey);
+        if (!parsedAPIKey.isValid) {
+          throw new Error("Invalid API key");
+        }
+        const iframeManager = new NcsIframeManager({ environment: parsedAPIKey.environment });
+        this.config.clientTEEConnection = yield iframeManager.initialize();
+      }
+    });
+  }
+  getTEEConnection() {
+    return __async(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 __async(this, null, function* () {
+      console.warn("TEE connection is not initialized, initializing now...");
+      const parsedAPIKey = validateAPIKey(this.config.crossmint.apiKey);
+      if (!parsedAPIKey.isValid) {
+        throw new Error("Invalid API key");
+      }
+      const iframeManager = new 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 __async(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: __spreadProps(__spreadValues({}, 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),
+            () => __async(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 AuthRejectedError());
+                  }
+                );
+              }
+              reject(new AuthRejectedError());
+            })
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }
+      try {
+        yield promise;
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  ensureAuthenticated() {
+    return __async(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 __async(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: __spreadProps(__spreadValues({}, 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 __async(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: __spreadProps(__spreadValues({}, 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 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 __async(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
+};
+
+export {
+  NonCustodialSigner,
+  DEFAULT_EVENT_OPTIONS
+};

package/dist/chunk-BFAU2NL6.js

@@ -0,0 +1,175 @@
+import {
+  Wallet
+} from "./chunk-4QGBVHV3.js";
+import {
+  InvalidTypedDataError,
+  SignatureNotCreatedError,
+  TransactionNotCreatedError
+} from "./chunk-SGINWAB6.js";
+import {
+  toViemChain
+} from "./chunk-KS63YEQ4.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/wallets/evm.ts
+import { createPublicClient, encodeFunctionData, http } from "viem";
+import { isValidEvmAddress } from "@crossmint/common-sdk-base";
+var EVMWallet = class _EVMWallet extends Wallet {
+  constructor(wallet) {
+    super(
+      {
+        chain: wallet.chain,
+        address: wallet.address,
+        owner: wallet.owner,
+        signer: wallet.signer,
+        options: Wallet.getOptions(wallet),
+        alias: wallet.alias
+      },
+      Wallet.getApiClient(wallet)
+    );
+  }
+  static from(wallet) {
+    if (!isValidEvmAddress(wallet.address)) {
+      throw new Error("Wallet is not an EVM wallet");
+    }
+    return new _EVMWallet(wallet);
+  }
+  sendTransaction(params) {
+    return __async(this, null, function* () {
+      var _a;
+      yield this.preAuthIfNeeded();
+      const builtTransaction = this.buildTransaction(params);
+      const createdTransaction = yield this.createTransaction(builtTransaction, params.options);
+      if ((_a = params.options) == null ? void 0 : _a.experimental_prepareOnly) {
+        return {
+          hash: void 0,
+          explorerLink: void 0,
+          transactionId: createdTransaction.id
+        };
+      }
+      return yield this.approveTransactionAndWait(createdTransaction.id);
+    });
+  }
+  signMessage(params) {
+    return __async(this, null, function* () {
+      var _a;
+      yield this.preAuthIfNeeded();
+      const signatureCreationResponse = yield this.apiClient.createSignature(this.walletLocator, {
+        type: "message",
+        params: {
+          message: params.message,
+          signer: this.signer.locator(),
+          chain: this.chain
+        }
+      });
+      if ("error" in signatureCreationResponse) {
+        throw new SignatureNotCreatedError(JSON.stringify(signatureCreationResponse));
+      }
+      if ((_a = params.options) == null ? void 0 : _a.experimental_prepareOnly) {
+        return {
+          signature: void 0,
+          signatureId: signatureCreationResponse.id
+        };
+      }
+      return yield this.approveSignatureAndWait(signatureCreationResponse.id);
+    });
+  }
+  signTypedData(params) {
+    return __async(this, null, function* () {
+      var _a;
+      yield this.preAuthIfNeeded();
+      const { domain, message, primaryType, types, chain } = params;
+      if (!domain || !message || !types || !chain) {
+        throw new InvalidTypedDataError("Invalid typed data");
+      }
+      const { name, version, chainId, verifyingContract, salt } = domain;
+      if (!name || !version || !chainId || !verifyingContract) {
+        throw new InvalidTypedDataError("Invalid typed data domain");
+      }
+      const signatureCreationResponse = yield this.apiClient.createSignature(this.walletLocator, {
+        type: "typed-data",
+        params: {
+          typedData: {
+            domain: {
+              name,
+              version,
+              chainId: Number(chainId),
+              verifyingContract,
+              salt
+            },
+            message,
+            primaryType,
+            types
+          },
+          signer: this.signer.locator(),
+          chain
+        }
+      });
+      if ("error" in signatureCreationResponse) {
+        throw new SignatureNotCreatedError(JSON.stringify(signatureCreationResponse));
+      }
+      if ((_a = params.options) == null ? void 0 : _a.experimental_prepareOnly) {
+        return {
+          signature: void 0,
+          signatureId: signatureCreationResponse.id
+        };
+      }
+      return yield this.approveSignatureAndWait(signatureCreationResponse.id);
+    });
+  }
+  getViemClient(params) {
+    var _a;
+    return createPublicClient({
+      transport: (_a = params == null ? void 0 : params.transport) != null ? _a : http(),
+      chain: toViemChain(this.chain)
+    });
+  }
+  createTransaction(transaction, options) {
+    return __async(this, null, function* () {
+      var _a;
+      const signer = (_a = options == null ? void 0 : options.experimental_signer) != null ? _a : this.signer.locator();
+      const transactionCreationResponse = yield this.apiClient.createTransaction(this.walletLocator, {
+        params: {
+          signer,
+          chain: this.chain,
+          calls: [transaction]
+        }
+      });
+      if ("error" in transactionCreationResponse) {
+        throw new TransactionNotCreatedError(JSON.stringify(transactionCreationResponse));
+      }
+      return transactionCreationResponse;
+    });
+  }
+  buildTransaction(params) {
+    var _a, _b, _c, _d, _e;
+    if ("transaction" in params) {
+      return { transaction: params.transaction };
+    }
+    if (params.abi == null) {
+      return {
+        to: params.to,
+        value: (_b = (_a = params.value) == null ? void 0 : _a.toString()) != null ? _b : "0",
+        data: (_c = params.data) != null ? _c : "0x"
+      };
+    }
+    if (!params.functionName) {
+      throw new Error("Function name is required");
+    }
+    return {
+      to: params.to,
+      value: (_e = (_d = params.value) == null ? void 0 : _d.toString()) != null ? _e : "0",
+      data: encodeFunctionData({
+        abi: params.abi,
+        functionName: params.functionName,
+        args: params.args
+      })
+    };
+  }
+};
+
+export {
+  EVMWallet
+};

package/dist/chunk-BSC55MYK.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/passkey.ts
+var _ox = require('ox');
+var PasskeySigner = class {
+  constructor(config) {
+    this.config = config;
+    this.type = "passkey";
+    this.id = config.id;
+  }
+  locator() {
+    return this.config.locator;
+  }
+  signMessage(message) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      if (this.config.onSignWithPasskey) {
+        return yield this.config.onSignWithPasskey(message);
+      }
+      const { signature, metadata } = yield _ox.WebAuthnP256.sign({
+        credentialId: this.id,
+        challenge: message
+      });
+      return {
+        signature: {
+          r: `0x${signature.r.toString(16)}`,
+          s: `0x${signature.s.toString(16)}`
+        },
+        metadata
+      };
+    });
+  }
+  signTransaction(transaction) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield this.signMessage(transaction);
+    });
+  }
+};
+
+
+
+exports.PasskeySigner = PasskeySigner;