@crossmint/wallets-sdk 0.18.2 → 0.18.4

package/dist/chunk-4QGBVHV3.js

@@ -0,0 +1,629 @@
+import {
+  NonCustodialSigner
+} from "./chunk-BAULM7A2.js";
+import {
+  STATUS_POLLING_INTERVAL_MS
+} from "./chunk-FAGFW4AR.js";
+import {
+  InvalidSignerError,
+  SignatureFailedError,
+  SignatureNotAvailableError,
+  SigningFailedError,
+  TransactionAwaitingApprovalError,
+  TransactionConfirmationTimeoutError,
+  TransactionFailedError,
+  TransactionHashNotFoundError,
+  TransactionNotAvailableError,
+  TransactionNotCreatedError,
+  TransactionSendingFailedError,
+  WalletNotAvailableError,
+  WalletTypeNotSupportedError
+} from "./chunk-SGINWAB6.js";
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-FPMW7Q5O.js";
+
+// src/wallets/wallet.ts
+import { isValidAddress } from "@crossmint/common-sdk-base";
+var _options, _apiClient;
+var Wallet = class {
+  constructor(args, apiClient) {
+    __privateAdd(this, _options);
+    __privateAdd(this, _apiClient);
+    const { chain, address, owner, signer, options, alias } = args;
+    __privateSet(this, _apiClient, apiClient);
+    this.chain = chain;
+    this.address = address;
+    this.owner = owner;
+    this.signer = signer;
+    __privateSet(this, _options, options);
+    this.alias = alias;
+  }
+  static getApiClient(wallet) {
+    return wallet.apiClient;
+  }
+  static getOptions(wallet) {
+    return wallet.options;
+  }
+  get apiClient() {
+    return __privateGet(this, _apiClient);
+  }
+  get options() {
+    return __privateGet(this, _options);
+  }
+  /**
+   * Get the API client
+   * @returns The API client
+   * @experimental This API is experimental and may change in the future
+   */
+  experimental_apiClient() {
+    return __privateGet(this, _apiClient);
+  }
+  /**
+   * Get the wallet balances - always includes USDC and native token (ETH/SOL)
+   * @param {string[]} tokens - Additional tokens to request (optional: native token and usdc are always included)
+   * @param {Chain[]} chains - The chains (optional)
+   * @returns {Promise<Balances<C>>} The balances returns nativeToken, usdc, tokens
+   * @throws {Error} If the balances cannot be retrieved
+   */
+  balances(tokens, chains) {
+    return __async(this, null, function* () {
+      let nativeToken;
+      switch (this.chain) {
+        case "solana":
+          nativeToken = "sol";
+          break;
+        case "stellar":
+          nativeToken = "xlm";
+          break;
+        default:
+          nativeToken = "eth";
+          break;
+      }
+      const allTokens = [nativeToken, "usdc", ...tokens != null ? tokens : []];
+      const response = yield __privateGet(this, _apiClient).getBalance(this.address, {
+        chains: chains != null ? chains : [this.chain],
+        tokens: allTokens
+      });
+      if ("error" in response) {
+        throw new Error(`Failed to get balances for wallet: ${JSON.stringify(response.message)}`);
+      }
+      return this.transformBalanceResponse(response, nativeToken, tokens);
+    });
+  }
+  /**
+   * Funds the wallet with Crossmint's stablecoin (USDXM).
+   *
+   * **Note:** This method is only available in staging environments and exclusively supports USDXM tokens.
+   * It cannot be used in production environments.
+   * @param amount - The amount of USDXM to fund the wallet with
+   * @param chain - Optional chain to fund on. If not provided, uses the wallet's default chain
+   * @returns The funding response
+   * @throws {Error} If the funding operation fails or if called in a production environment
+   */
+  stagingFund(amount, chain) {
+    return __async(this, null, function* () {
+      const response = yield this.apiClient.fundWallet(this.address, {
+        amount,
+        token: "usdxm",
+        // Type casting is necessary here due to a type mismatch between our DTO schema and server-side types
+        // (which only contains 10 testnet chains. Variable in main server is called EvmUsdcEnabledTestnetChains for reference).
+        chain: chain != null ? chain : this.chain
+      });
+      if ("error" in response) {
+        throw new Error(`Failed to fund wallet: ${JSON.stringify(response.message)}`);
+      }
+      return response;
+    });
+  }
+  /**
+   * Transform the API balance response to the new structure
+   * @private
+   */
+  transformBalanceResponse(apiResponse, nativeTokenSymbol, requestedTokens) {
+    const transformTokenBalance = (tokenData) => {
+      var _a, _b, _c, _d, _e;
+      const chainData = (_a = tokenData.chains) == null ? void 0 : _a[this.chain];
+      let chainSpecificField = {};
+      if (this.chain === "solana" && chainData != null && "mintHash" in chainData) {
+        chainSpecificField = { mintHash: chainData.mintHash };
+      } else if (this.chain === "stellar" && chainData != null && "contractId" in chainData) {
+        chainSpecificField = { contractId: chainData.contractId };
+      } else if (chainData != null && "contractAddress" in chainData) {
+        chainSpecificField = { contractAddress: chainData.contractAddress };
+      }
+      return __spreadValues({
+        symbol: (_b = tokenData.symbol) != null ? _b : "",
+        name: (_c = tokenData.name) != null ? _c : "",
+        amount: (_d = tokenData.amount) != null ? _d : "0",
+        decimals: tokenData.decimals,
+        rawAmount: (_e = tokenData.rawAmount) != null ? _e : "0"
+      }, chainSpecificField);
+    };
+    const nativeTokenData = apiResponse.find((token) => token.symbol === nativeTokenSymbol);
+    const usdcData = apiResponse.find((token) => token.symbol === "usdc");
+    const otherTokens = apiResponse.filter((token) => {
+      return token.symbol !== nativeTokenSymbol && token.symbol !== "usdc";
+    });
+    const createDefaultToken = (symbol) => {
+      const baseToken = {
+        symbol,
+        name: symbol,
+        amount: "0",
+        decimals: 0,
+        rawAmount: "0"
+      };
+      let chainSpecificField = {};
+      if (this.chain === "solana") {
+        chainSpecificField = { mintHash: void 0 };
+      } else if (this.chain === "stellar") {
+        chainSpecificField = { contractId: void 0 };
+      } else {
+        chainSpecificField = { contractAddress: void 0 };
+      }
+      return __spreadValues(__spreadValues({}, baseToken), chainSpecificField);
+    };
+    return {
+      nativeToken: nativeTokenData != null ? transformTokenBalance(nativeTokenData) : createDefaultToken(nativeTokenSymbol),
+      usdc: usdcData != null ? transformTokenBalance(usdcData) : createDefaultToken("usdc"),
+      tokens: otherTokens.map(transformTokenBalance)
+    };
+  }
+  /**
+   * Get the wallet NFTs
+   * @param {Object} params - The parameters
+   * @param {number} params.perPage - The number of NFTs per page
+   * @param {number} params.page - The page number
+   * @param {WalletLocator} [params.locator] - The locator
+   * @returns The NFTs
+   * @experimental This API is experimental and may change in the future
+   */
+  experimental_nfts(params) {
+    return __async(this, null, function* () {
+      return yield __privateGet(this, _apiClient).experimental_getNfts(__spreadProps(__spreadValues({}, params), {
+        chain: this.chain,
+        address: this.address
+      }));
+    });
+  }
+  /**
+   * Get the wallet transactions
+   * @returns The transactions
+   * @throws {Error} If the transactions cannot be retrieved
+   */
+  experimental_transactions() {
+    return __async(this, null, function* () {
+      const response = yield __privateGet(this, _apiClient).getTransactions(this.walletLocator);
+      if ("error" in response) {
+        throw new Error(`Failed to get transactions: ${JSON.stringify(response.message)}`);
+      }
+      return response;
+    });
+  }
+  /**
+   * Get a transaction by id
+   * @returns The transaction
+   * @throws {Error} If the transaction cannot be retrieved
+   */
+  experimental_transaction(transactionId) {
+    return __async(this, null, function* () {
+      const response = yield __privateGet(this, _apiClient).getTransaction(this.walletLocator, transactionId);
+      if ("error" in response) {
+        throw new Error(`Failed to get transaction: ${JSON.stringify(response.error)}`);
+      }
+      return response;
+    });
+  }
+  /**
+   * Get the wallet activity
+   * @returns The activity
+   * @experimental This API is experimental and may change in the future
+   * @throws {Error} If the activity cannot be retrieved
+   */
+  experimental_activity() {
+    return __async(this, null, function* () {
+      const response = yield this.apiClient.experimental_activity(this.walletLocator, { chain: this.chain });
+      if ("error" in response) {
+        throw new Error(`Failed to get activity: ${JSON.stringify(response.message)}`);
+      }
+      return response;
+    });
+  }
+  /**
+   * Send a token to a wallet or user locator
+   * @param {string | UserLocator} to - The recipient (address or user locator)
+   * @param {string} token - The token (address or currency symbol)
+   * @param {string} amount - The amount to send (decimal units)
+   * @param {TransactionInputOptions} options - The options for the transaction
+   * @returns {Transaction} The transaction
+   */
+  send(to, token, amount, options) {
+    return __async(this, null, function* () {
+      yield this.preAuthIfNeeded();
+      const recipient = toRecipientLocator(to);
+      const tokenLocator = toTokenLocator(token, this.chain);
+      const sendParams = __spreadValues({
+        recipient,
+        amount
+      }, (options == null ? void 0 : options.experimental_signer) != null ? { signer: options.experimental_signer } : {});
+      const transactionCreationResponse = yield __privateGet(this, _apiClient).send(this.walletLocator, tokenLocator, sendParams);
+      if ("message" in transactionCreationResponse) {
+        throw new TransactionNotCreatedError(
+          `Failed to send token: ${JSON.stringify(transactionCreationResponse.message)}`
+        );
+      }
+      if (options == null ? void 0 : options.experimental_prepareOnly) {
+        return {
+          hash: void 0,
+          explorerLink: void 0,
+          transactionId: transactionCreationResponse.id
+        };
+      }
+      return yield this.approveTransactionAndWait(transactionCreationResponse.id);
+    });
+  }
+  /**
+   * @deprecated Use `approve` instead.
+   * Approve a transaction
+   * @param params - The parameters
+   * @param params.transactionId - The transaction id
+   * @param params.options - The options for the transaction
+   * @param params.options.experimental_approval - The approval
+   * @param params.options.additionalSigners - The additional signers
+   * @returns The transaction
+   */
+  // TODO: Remove this method in the next major version
+  approveTransaction(params) {
+    return __async(this, null, function* () {
+      console.warn(
+        "approveTransaction is deprecated. Use approve instead. This method will be removed in the next major version."
+      );
+      return yield this.approve(params);
+    });
+  }
+  /**
+   * Approve a transaction or signature
+   * @param params - The parameters
+   * @param params.transactionId - The transaction id or
+   * @param params.signatureId - The signature id
+   * @param params.options - The options for the transaction
+   * @param params.options.experimental_approval - The approval
+   * @param params.options.additionalSigners - The additional signers
+   * @returns The transaction or signature
+   */
+  approve(params) {
+    return __async(this, null, function* () {
+      if (params.transactionId != null) {
+        return yield this.approveTransactionAndWait(params.transactionId, params.options);
+      }
+      if (params.signatureId != null) {
+        return yield this.approveSignatureAndWait(params.signatureId, params.options);
+      }
+      throw new Error("Either transactionId or signatureId must be provided");
+    });
+  }
+  /**
+   * Add a delegated signer to the wallet
+   * @param signer - The signer. For Solana, it must be a string. For EVM, it can be a string or a passkey.
+   * @param options - The options for the operation
+   * @param options.experimental_prepareOnly - If true, returns the transaction/signature ID without auto-approving
+   */
+  addDelegatedSigner(params) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const response = yield __privateGet(this, _apiClient).registerSigner(this.walletLocator, {
+        signer: params.signer,
+        chain: this.chain === "solana" || this.chain === "stellar" ? void 0 : this.chain
+      });
+      if ("error" in response) {
+        throw new Error(`Failed to register signer: ${JSON.stringify(response.message)}`);
+      }
+      if (this.chain === "solana" || this.chain === "stellar") {
+        if (!("transaction" in response) || response.transaction == null) {
+          throw new Error("Expected transaction in response for Solana/Stellar chain");
+        }
+        const transactionId = response.transaction.id;
+        if ((_a = params.options) == null ? void 0 : _a.experimental_prepareOnly) {
+          return { transactionId };
+        }
+        yield this.approveTransactionAndWait(transactionId);
+        return void 0;
+      }
+      if (!("chains" in response)) {
+        throw new Error("Expected chains in response for EVM chain");
+      }
+      const chainResponse = (_b = response.chains) == null ? void 0 : _b[this.chain];
+      if ((_c = params.options) == null ? void 0 : _c.experimental_prepareOnly) {
+        const signatureId = (chainResponse == null ? void 0 : chainResponse.status) !== "success" ? chainResponse == null ? void 0 : chainResponse.id : void 0;
+        return { signatureId };
+      }
+      if ((chainResponse == null ? void 0 : chainResponse.status) === "awaiting-approval") {
+        yield this.approveSignatureAndWait(chainResponse.id);
+        return void 0;
+      }
+      if ((chainResponse == null ? void 0 : chainResponse.status) === "pending") {
+        yield this.waitForSignature(chainResponse.id);
+        return void 0;
+      }
+      return void 0;
+    });
+  }
+  delegatedSigners() {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const walletResponse = yield __privateGet(this, _apiClient).getWallet(this.walletLocator);
+      if ("error" in walletResponse) {
+        throw new WalletNotAvailableError(JSON.stringify(walletResponse));
+      }
+      if (walletResponse.type !== "smart" || walletResponse.chainType !== "evm" && walletResponse.chainType !== "solana" && walletResponse.chainType !== "stellar") {
+        throw new WalletTypeNotSupportedError(`Wallet type ${walletResponse.type} not supported`);
+      }
+      return (_c = (_b = (_a = walletResponse == null ? void 0 : walletResponse.config) == null ? void 0 : _a.delegatedSigners) == null ? void 0 : _b.map((signer) => {
+        const colonIndex = signer.locator.indexOf(":");
+        const address = colonIndex >= 0 ? signer.locator.slice(colonIndex + 1) : signer.locator;
+        return {
+          signer: `external-wallet:${address}`
+        };
+      })) != null ? _c : [];
+    });
+  }
+  get walletLocator() {
+    if (__privateGet(this, _apiClient).isServerSide) {
+      return this.address;
+    } else {
+      let baseLocator;
+      switch (this.chain) {
+        case "stellar":
+          baseLocator = `me:stellar:smart`;
+          break;
+        case "solana":
+          baseLocator = `me:solana:smart`;
+          break;
+        default:
+          baseLocator = `me:evm:smart`;
+          break;
+      }
+      const aliasLocatorPart = this.alias != null ? `:alias:${this.alias}` : "";
+      return baseLocator + aliasLocatorPart;
+    }
+  }
+  preAuthIfNeeded() {
+    return __async(this, null, function* () {
+      if (this.signer instanceof NonCustodialSigner) {
+        yield this.signer.ensureAuthenticated();
+      }
+    });
+  }
+  get isSolanaWallet() {
+    return this.chain === "solana";
+  }
+  approveTransactionAndWait(transactionId, options) {
+    return __async(this, null, function* () {
+      yield this.approveTransactionInternal(transactionId, options);
+      yield this.sleep(1e3);
+      return yield this.waitForTransaction(transactionId);
+    });
+  }
+  approveSignatureAndWait(signatureId, options) {
+    return __async(this, null, function* () {
+      const signatureResponse = yield this.approveSignatureInternal(signatureId, options);
+      if (!("error" in signatureResponse) && signatureResponse.status === "success" && signatureResponse.outputSignature != null) {
+        return {
+          signature: signatureResponse.outputSignature,
+          signatureId
+        };
+      }
+      yield this.sleep(1e3);
+      return yield this.waitForSignature(signatureId);
+    });
+  }
+  approveSignatureInternal(signatureId, options) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.isSolanaWallet) {
+        throw new Error("Approving signatures is only supported for EVM smart wallets");
+      }
+      const signature = yield __privateGet(this, _apiClient).getSignature(this.walletLocator, signatureId);
+      if ("error" in signature) {
+        throw new SignatureNotAvailableError(JSON.stringify(signature));
+      }
+      if (this.signer.type === "api-key") {
+        return signature;
+      }
+      if ((options == null ? void 0 : options.experimental_approval) != null) {
+        const approvals2 = [options.experimental_approval];
+        return yield this.executeApproveSignatureWithErrorHandling(signatureId, approvals2);
+      }
+      const pendingApprovals = (_a = signature.approvals) == null ? void 0 : _a.pending;
+      if (pendingApprovals == null) {
+        return signature;
+      }
+      const signers = [...(_b = options == null ? void 0 : options.additionalSigners) != null ? _b : [], this.signer];
+      const signedApprovals = yield Promise.all(
+        pendingApprovals.map((pendingApproval) => {
+          const signer = signers.find((s) => s.locator() === pendingApproval.signer.locator);
+          if (signer == null) {
+            throw new InvalidSignerError(`Signer ${pendingApproval.signer} not found in pending approvals`);
+          }
+          return signer.signMessage(pendingApproval.message);
+        })
+      );
+      const approvals = signedApprovals.map((signature2) => {
+        return __spreadProps(__spreadValues({}, signature2), {
+          signer: this.signer.locator()
+        });
+      });
+      return yield this.executeApproveSignatureWithErrorHandling(signatureId, approvals);
+    });
+  }
+  approveTransactionInternal(transactionId, options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      const transaction = yield __privateGet(this, _apiClient).getTransaction(this.walletLocator, transactionId);
+      if ("error" in transaction) {
+        throw new TransactionNotAvailableError(JSON.stringify(transaction));
+      }
+      yield (_c = (_b = (_a = __privateGet(this, _options)) == null ? void 0 : _a.experimental_callbacks) == null ? void 0 : _b.onTransactionStart) == null ? void 0 : _c.call(_b);
+      if (this.signer.type === "api-key") {
+        return transaction;
+      }
+      if ((options == null ? void 0 : options.experimental_approval) != null) {
+        const approvals2 = [options.experimental_approval];
+        return yield this.executeApproveTransactionWithErrorHandling(transactionId, approvals2);
+      }
+      const pendingApprovals = (_d = transaction.approvals) == null ? void 0 : _d.pending;
+      if (pendingApprovals == null) {
+        return transaction;
+      }
+      const signers = [...(_e = options == null ? void 0 : options.additionalSigners) != null ? _e : [], this.signer];
+      const signedApprovals = yield Promise.all(
+        pendingApprovals.map((pendingApproval) => {
+          const signer = signers.find((s) => s.locator() === pendingApproval.signer.locator);
+          if (signer == null) {
+            throw new InvalidSignerError(`Signer ${pendingApproval.signer} not found in pending approvals`);
+          }
+          const transactionToSign = transaction.chainType === "solana" && "transaction" in transaction.onChain ? transaction.onChain.transaction : pendingApproval.message;
+          return signer.signTransaction(transactionToSign);
+        })
+      );
+      const approvals = signedApprovals.map((signature) => {
+        return __spreadProps(__spreadValues({}, signature), {
+          signer: this.signer.locator()
+        });
+      });
+      return yield this.executeApproveTransactionWithErrorHandling(transactionId, approvals);
+    });
+  }
+  executeApproveTransactionWithErrorHandling(transactionId, approvals) {
+    return __async(this, null, function* () {
+      const approvedTransaction = yield __privateGet(this, _apiClient).approveTransaction(this.walletLocator, transactionId, {
+        approvals
+      });
+      if (approvedTransaction.error) {
+        throw new TransactionFailedError(JSON.stringify(approvedTransaction));
+      }
+      return approvedTransaction;
+    });
+  }
+  executeApproveSignatureWithErrorHandling(signatureId, approvals) {
+    return __async(this, null, function* () {
+      const approvedSignature = yield __privateGet(this, _apiClient).approveSignature(this.walletLocator, signatureId, {
+        approvals
+      });
+      if (approvedSignature.error) {
+        throw new SignatureFailedError(JSON.stringify(approvedSignature));
+      }
+      return approvedSignature;
+    });
+  }
+  waitForSignature(signatureId) {
+    return __async(this, null, function* () {
+      let signatureResponse = null;
+      do {
+        yield new Promise((resolve) => setTimeout(resolve, STATUS_POLLING_INTERVAL_MS));
+        signatureResponse = yield __privateGet(this, _apiClient).getSignature(this.walletLocator, signatureId);
+        if ("error" in signatureResponse) {
+          throw new SignatureNotAvailableError(JSON.stringify(signatureResponse));
+        }
+      } while (signatureResponse === null || signatureResponse.status === "pending");
+      if (signatureResponse.status === "failed") {
+        throw new SigningFailedError("Signature signing failed");
+      }
+      if (!signatureResponse.outputSignature) {
+        throw new SignatureNotAvailableError("Signature not available");
+      }
+      return {
+        signature: signatureResponse.outputSignature,
+        signatureId
+      };
+    });
+  }
+  waitForTransaction(_0) {
+    return __async(this, arguments, function* (transactionId, timeoutMs = 6e4, {
+      backoffMultiplier = 1.1,
+      maxBackoffMs = 2e3,
+      initialBackoffMs = STATUS_POLLING_INTERVAL_MS
+    } = {}) {
+      var _a;
+      const startTime = Date.now();
+      let transactionResponse;
+      do {
+        if (Date.now() - startTime > timeoutMs) {
+          const error = new TransactionConfirmationTimeoutError("Transaction confirmation timeout");
+          throw error;
+        }
+        transactionResponse = yield __privateGet(this, _apiClient).getTransaction(this.walletLocator, transactionId);
+        if (transactionResponse.error) {
+          throw new TransactionNotAvailableError(JSON.stringify(transactionResponse));
+        }
+        yield this.sleep(initialBackoffMs);
+        initialBackoffMs = Math.min(initialBackoffMs * backoffMultiplier, maxBackoffMs);
+      } while (transactionResponse.status === "pending");
+      if (transactionResponse.status === "failed") {
+        const error = new TransactionSendingFailedError(
+          `Transaction sending failed: ${JSON.stringify(transactionResponse.error)}`
+        );
+        throw error;
+      }
+      if (transactionResponse.status === "awaiting-approval") {
+        const error = new TransactionAwaitingApprovalError(
+          `Transaction is awaiting approval. Please submit required approvals before waiting for completion.`
+        );
+        throw error;
+      }
+      const transactionHash = transactionResponse.onChain.txId;
+      if (transactionHash == null) {
+        const error = new TransactionHashNotFoundError("Transaction hash not found on transaction response");
+        throw error;
+      }
+      return {
+        hash: transactionHash,
+        explorerLink: (_a = transactionResponse.onChain.explorerLink) != null ? _a : "",
+        transactionId: transactionResponse.id
+      };
+    });
+  }
+  sleep(ms) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    });
+  }
+};
+_options = new WeakMap();
+_apiClient = new WeakMap();
+function toRecipientLocator(to) {
+  if (typeof to === "string") {
+    return to;
+  }
+  if ("email" in to) {
+    return `email:${to.email}`;
+  }
+  if ("x" in to) {
+    return `x:${to.x}`;
+  }
+  if ("twitter" in to) {
+    return `twitter:${to.twitter}`;
+  }
+  if ("phone" in to) {
+    return `phoneNumber:${to.phone}`;
+  }
+  if ("userId" in to) {
+    return `userId:${to.userId}`;
+  }
+  throw new Error("Invalid recipient locator");
+}
+function toTokenLocator(token, chain) {
+  if (isValidAddress(token)) {
+    return `${chain}:${token}`;
+  }
+  return `${chain}:${token.toLowerCase()}`;
+}
+
+export {
+  Wallet
+};

package/dist/chunk-55V4VMTX.cjs

@@ -0,0 +1,25 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/chains/definitions/storyTestnet.ts
+var _viem = require('viem');
+var storyTestnet = _viem.defineChain.call(void 0, {
+  id: 1513,
+  name: "Story Testnet",
+  nativeCurrency: {
+    decimals: 18,
+    name: "IP",
+    symbol: "IP"
+  },
+  rpcUrls: {
+    default: { http: ["https://testnet.storyrpc.io"] }
+  },
+  blockExplorers: {
+    default: {
+      name: "Story Testnet Explorer",
+      url: "https://testnet.storyscan.xyz"
+    }
+  },
+  testnet: true
+});
+
+
+
+exports.storyTestnet = storyTestnet;