@crossmint/wallets-sdk 0.18.3 → 0.18.6

package/dist/chunk-LKAO2MV2.cjs

@@ -0,0 +1,80 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkB6JOIWRHcjs = require('./chunk-B6JOIWRH.cjs');
+
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/non-custodial/ncs-evm-signer.ts
+var _ox = require('ox');
+var _viem = require('viem');
+var EVMNonCustodialSigner = class _EVMNonCustodialSigner extends _chunkB6JOIWRHcjs.NonCustodialSigner {
+  constructor(config) {
+    super(config);
+  }
+  signMessage(message) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      const messageRaw = _viem.isHex.call(void 0, message) ? message : _viem.toHex.call(void 0, message);
+      const messageToSign = _ox.PersonalMessage.getSignPayload(messageRaw);
+      return yield this.sign(messageToSign);
+    });
+  }
+  signTransaction(transaction) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield this.sign(transaction);
+    });
+  }
+  sign(raw) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, 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: _chunkB6JOIWRHcjs.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"
+    };
+  }
+};
+
+
+
+exports.EVMNonCustodialSigner = EVMNonCustodialSigner;

package/dist/chunk-LLFD22UQ.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/solana-api-key.ts
+var SolanaApiKeySigner = 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.SolanaApiKeySigner = SolanaApiKeySigner;

package/dist/chunk-MZBFXUHT.js

@@ -0,0 +1,63 @@
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// 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 __async(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 __async(this, null, function* () {
+      return yield this.signMessage(transaction);
+    });
+  }
+};
+
+export {
+  EVMExternalWalletSigner
+};

package/dist/chunk-NIBKCMQ2.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/chains/definitions/story.ts
+var _viem = require('viem');
+var story = _viem.defineChain.call(void 0, {
+  id: 1514,
+  name: "Story",
+  nativeCurrency: {
+    decimals: 18,
+    name: "IP Token",
+    symbol: "IP"
+  },
+  rpcUrls: {
+    default: { http: ["https://mainnet.storyrpc.io"] }
+  },
+  testnet: false
+});
+
+
+
+exports.story = story;

package/dist/chunk-OKXSUK63.js

@@ -0,0 +1,87 @@
+import {
+  Wallet
+} from "./chunk-UKBWSQ7R.js";
+import {
+  TransactionNotCreatedError
+} from "./chunk-SGINWAB6.js";
+import {
+  __async
+} from "./chunk-FPMW7Q5O.js";
+
+// src/wallets/stellar.ts
+import { isValidStellarAddress } from "@crossmint/common-sdk-base";
+var StellarWallet = class _StellarWallet 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 (!isValidStellarAddress(wallet.address)) {
+      throw new Error("Wallet is not a Stellar wallet");
+    }
+    return new _StellarWallet(wallet);
+  }
+  sendTransaction(params) {
+    return __async(this, null, function* () {
+      var _a;
+      yield this.preAuthIfNeeded();
+      const createdTransaction = yield this.createTransaction(params);
+      if ((_a = params.options) == null ? void 0 : _a.experimental_prepareOnly) {
+        return {
+          hash: void 0,
+          explorerLink: void 0,
+          transactionId: createdTransaction.id
+        };
+      }
+      const options = {};
+      return yield this.approveTransactionAndWait(createdTransaction.id, options);
+    });
+  }
+  createTransaction(params) {
+    return __async(this, null, function* () {
+      var _a;
+      const { contractId, options } = params;
+      const signer = (_a = options == null ? void 0 : options.experimental_signer) != null ? _a : this.signer.locator();
+      let transaction;
+      if ("transaction" in params) {
+        transaction = {
+          type: "serialized-transaction",
+          serializedTransaction: params.transaction,
+          contractId
+        };
+      } else {
+        const { method, memo, args } = params;
+        transaction = {
+          type: "contract-call",
+          contractId,
+          method,
+          memo: memo != null ? { type: "text", value: memo } : void 0,
+          args
+        };
+      }
+      const transactionCreationResponse = yield this.apiClient.createTransaction(this.walletLocator, {
+        params: {
+          transaction,
+          signer
+        }
+      });
+      if ("error" in transactionCreationResponse) {
+        throw new TransactionNotCreatedError(JSON.stringify(transactionCreationResponse));
+      }
+      return transactionCreationResponse;
+    });
+  }
+};
+
+export {
+  StellarWallet
+};

package/dist/chunk-R2OY54EJ.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkXC2V34TScjs = require('./chunk-XC2V34TS.cjs');
+
+
+var _chunkG5NYLGM5cjs = require('./chunk-G5NYLGM5.cjs');
+
+// src/signers/solana-external-wallet.ts
+var _web3js = require('@solana/web3.js');
+var _bs58 = require('bs58'); var _bs582 = _interopRequireDefault(_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 _chunkG5NYLGM5cjs.__async.call(void 0, this, null, function* () {
+      return yield Promise.reject(new Error("signMessage method not implemented for solana external wallet signer"));
+    });
+  }
+  signTransaction(transaction) {
+    return _chunkG5NYLGM5cjs.__async.call(void 0, 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 = _bs582.default.decode(transaction);
+      const deserializedTransaction = _web3js.VersionedTransaction.deserialize(transactionBytes);
+      const signedTxn = yield this.onSignTransaction(deserializedTransaction);
+      const externalWalletPublicKey = new (0, _web3js.PublicKey)(this._address);
+      const signerIndex = signedTxn.message.staticAccountKeys.findIndex((key) => key.equals(externalWalletPublicKey));
+      if (signerIndex === -1) {
+        throw new (0, _chunkXC2V34TScjs.TransactionFailedError)("Wallet public key not found in transaction signers");
+      }
+      const validSignature = signedTxn.signatures[signerIndex];
+      if (validSignature == null) {
+        throw new (0, _chunkXC2V34TScjs.TransactionFailedError)("No valid signature found in the transaction");
+      }
+      const signatureBytes = new Uint8Array(Object.values(validSignature));
+      return { signature: _bs582.default.encode(signatureBytes) };
+    });
+  }
+};
+
+
+
+exports.SolanaExternalWalletSigner = SolanaExternalWalletSigner;

package/dist/chunk-RAWKXOHR.js

@@ -0,0 +1,53 @@
+import {
+  SDK_NAME,
+  SDK_VERSION
+} from "./chunk-WQVJM3PG.js";
+
+// src/logger/init.ts
+import {
+  SdkLogger,
+  BrowserDatadogSink,
+  detectPlatform,
+  validateAPIKey,
+  ServerDatadogSink
+} from "@crossmint/common-sdk-base";
+import * as datadogLogger from "@datadog/browser-logs";
+var walletsLogger = new SdkLogger();
+function initWalletsLogger(apiKey) {
+  const platform = detectPlatform();
+  const validationResult = validateAPIKey(apiKey);
+  if (!validationResult.isValid) {
+    throw new Error(`Invalid API key: ${validationResult.message}`);
+  }
+  const { environment, projectId } = validationResult;
+  walletsLogger.init({
+    packageName: SDK_NAME,
+    packageVersion: SDK_VERSION,
+    environment,
+    projectId,
+    platform
+  });
+  switch (platform) {
+    case "browser": {
+      const sink = new BrowserDatadogSink(environment, datadogLogger);
+      walletsLogger.addSink(sink);
+      break;
+    }
+    case "react-native": {
+      break;
+    }
+    case "server": {
+      const sink = new ServerDatadogSink(environment);
+      walletsLogger.addSink(sink);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+export {
+  walletsLogger,
+  initWalletsLogger
+};

package/dist/chunk-RBHGZDDX.cjs

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkXC2V34TScjs = require('./chunk-XC2V34TS.cjs');
+
+// src/utils/signer-validation.ts
+var _commonsdkauth = require('@crossmint/common-sdk-auth');
+var signerConfigMismatchErrorMessage = (fieldPath, newValue, existingValue) => `Wallet signer configuration mismatch at "${fieldPath}" - expected "${existingValue}" from existing wallet but found "${newValue}"`;
+function normalizeEmail(email) {
+  const lowerCaseEmail = email.toLowerCase();
+  const emailParts = lowerCaseEmail.split("@");
+  const domain = emailParts[1];
+  const isGoogleMailDomain = domain === "googlemail.com";
+  const isGmail = isGoogleMailDomain || domain === "gmail.com";
+  const isGmailAndHasDots = isGmail && emailParts[0].includes(".");
+  if (isGoogleMailDomain) {
+    emailParts[1] = "gmail.com";
+  }
+  if (isGmailAndHasDots) {
+    emailParts[0] = emailParts[0].replace(/\./g, "");
+  }
+  return `${emailParts[0]}@${emailParts[1]}`;
+}
+function normalizeValueForComparison(value) {
+  if (typeof value === "string" && _commonsdkauth.isEmailValid.call(void 0, value)) {
+    return normalizeEmail(value);
+  }
+  return value;
+}
+function compareSignerConfigs(newSignerConfig, existingSignerConfig, path = "") {
+  if (newSignerConfig === existingSignerConfig) {
+    return;
+  }
+  if (newSignerConfig == null || existingSignerConfig == null) {
+    throw new Error(`Cannot compare null or undefined signer configs at path: ${path}`);
+  }
+  for (const key of Object.keys(newSignerConfig)) {
+    if (!(key in existingSignerConfig)) {
+      continue;
+    }
+    const fieldPath = path ? `${path}.${key}` : key;
+    const newValue = newSignerConfig[key];
+    const existingValue = existingSignerConfig[key];
+    if (typeof newValue === "object" && newValue !== null && typeof existingValue === "object" && existingValue !== null) {
+      compareSignerConfigs(
+        newValue,
+        existingValue,
+        fieldPath
+      );
+    } else if (normalizeValueForComparison(newValue) !== normalizeValueForComparison(existingValue)) {
+      throw new (0, _chunkXC2V34TScjs.WalletCreationError)(signerConfigMismatchErrorMessage(fieldPath, newValue, existingValue));
+    }
+  }
+}
+
+
+
+
+exports.normalizeValueForComparison = normalizeValueForComparison; exports.compareSignerConfigs = compareSignerConfigs;

package/dist/chunk-RHR6P2KP.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/signers/types.ts
+var AuthRejectedError = class extends Error {
+  constructor() {
+    super("Authentication was rejected by the user");
+    this.name = "AuthRejectedError";
+  }
+};
+function isExportableSigner(signer) {
+  return signer._exportPrivateKey !== void 0;
+}
+
+
+
+
+exports.AuthRejectedError = AuthRejectedError; exports.isExportableSigner = isExportableSigner;