@caatinga/client 0.2.4 → 2.0.1

package/dist/index.js

@@ -8,12 +8,38 @@ function resolveContractId(input) {
   if (contractId) {
     return contractId;
   }
+  const hint = formatMissingContractArtifactHint(input.artifacts, input.network, input.contract);
   throw new CaatingaError(
     `No contract artifact found for "${input.contract}" on "${input.network}".`,
     CaatingaErrorCode.CONTRACT_ARTIFACT_NOT_FOUND,
-    "Deploy the contract first or pass contractId explicitly."
+    hint
   );
 }
+function formatMissingContractArtifactHint(artifacts, network, contract) {
+  const deployCommand = `caatinga deploy ${contract} --network ${network} --source <identity>`;
+  const buildNote = "caatinga build does not register a contract ID.";
+  if (Object.keys(artifacts.networks).length === 0) {
+    return [
+      "caatinga.artifacts.json has no network scaffold.",
+      `Run caatinga doctor --network ${network} to inspect deploy readiness, then run: ${deployCommand}.`,
+      buildNote,
+      "Or pass contractId in the client registration."
+    ].join(" ");
+  }
+  if (!artifacts.networks[network]) {
+    return [
+      `No artifacts exist for network "${network}".`,
+      `Run: ${deployCommand}.`,
+      buildNote,
+      "Or pass contractId in the client registration."
+    ].join(" ");
+  }
+  return [
+    `Contract "${contract}" is not deployed on "${network}".`,
+    `Run: ${deployCommand}.`,
+    "Or pass contractId in the client registration."
+  ].join(" ");
+}
 
 // src/bindings/default-binding-adapter.ts
 import { CaatingaError as CaatingaError2, CaatingaErrorCode as CaatingaErrorCode2 } from "@caatinga/core/browser";
@@ -50,10 +76,10 @@ function createDefaultBindingAdapter(binding) {
 }
 
 // src/client/create-caatinga-client.ts
-import { CaatingaError as CaatingaError5, CaatingaErrorCode as CaatingaErrorCode5 } from "@caatinga/core/browser";
+import { CaatingaError as CaatingaError8, CaatingaErrorCode as CaatingaErrorCode8 } from "@caatinga/core/browser";
 
 // src/client/caatinga-contract-client.ts
-import { CaatingaError as CaatingaError4, CaatingaErrorCode as CaatingaErrorCode4 } from "@caatinga/core/browser";
+import { CaatingaError as CaatingaError7, CaatingaErrorCode as CaatingaErrorCode7 } from "@caatinga/core/browser";
 
 // src/xdr/build-xdr.ts
 import { CaatingaError as CaatingaError3, CaatingaErrorCode as CaatingaErrorCode3 } from "@caatinga/core/browser";
@@ -112,6 +138,188 @@ function readXdr(transaction) {
   return candidate.toXDR();
 }
 
+// src/wallet/with-wallet-timeout.ts
+import { CaatingaError as CaatingaError4, CaatingaErrorCode as CaatingaErrorCode4 } from "@caatinga/core/browser";
+function withWalletTimeout(label, timeoutMs, fn) {
+  if (timeoutMs === void 0 || timeoutMs <= 0) {
+    return fn();
+  }
+  let timedOut = false;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      timedOut = true;
+      reject(
+        new CaatingaError4(
+          `Wallet "${label}" timed out after ${timeoutMs}ms.`,
+          CaatingaErrorCode4.WALLET_TIMEOUT,
+          "Ensure the wallet adapter rejects on user dismissal, or increase walletTimeout."
+        )
+      );
+    }, timeoutMs);
+    fn().then(
+      (value) => {
+        if (timedOut) {
+          return;
+        }
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        if (timedOut) {
+          return;
+        }
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/client/invoke-args.ts
+function splitArgsAndOptions(argsOrOptions, maybeOptions) {
+  return {
+    args: argsOrOptions,
+    debugRaw: maybeOptions?.debugRaw ?? false
+  };
+}
+function splitInvokeArgsAndOptions(argsOrOptions, maybeOptions) {
+  const looksLikeOptions = argsOrOptions !== void 0 && ("debugXdr" in argsOrOptions || "debugRaw" in argsOrOptions) && maybeOptions === void 0;
+  if (looksLikeOptions) {
+    const options = argsOrOptions;
+    return {
+      args: void 0,
+      debugXdr: options.debugXdr ?? false,
+      debugRaw: options.debugRaw ?? false
+    };
+  }
+  return {
+    args: argsOrOptions,
+    debugXdr: maybeOptions?.debugXdr ?? false,
+    debugRaw: maybeOptions?.debugRaw ?? false
+  };
+}
+function splitReadArgsAndOptions(argsOrOptions, maybeOptions) {
+  const looksLikeOptions = argsOrOptions !== void 0 && "debugRaw" in argsOrOptions && maybeOptions === void 0;
+  if (looksLikeOptions) {
+    const options = argsOrOptions;
+    return {
+      args: void 0,
+      debugRaw: options.debugRaw ?? false
+    };
+  }
+  return {
+    args: argsOrOptions,
+    debugRaw: maybeOptions?.debugRaw ?? false
+  };
+}
+
+// src/client/transaction-simulate.ts
+import { CaatingaError as CaatingaError5, CaatingaErrorCode as CaatingaErrorCode5 } from "@caatinga/core/browser";
+async function prepareReadTransaction(transaction, contractName, method, rpcUrl) {
+  const candidate = transaction;
+  if (typeof candidate.prepare !== "function") {
+    return transaction;
+  }
+  try {
+    return await candidate.prepare.call(transaction);
+  } catch (error) {
+    if (error instanceof CaatingaError5) {
+      throw error;
+    }
+    throw new CaatingaError5(
+      `Failed to prepare XDR for "${contractName}.${method}".`,
+      CaatingaErrorCode5.XDR_PREPARE_FAILED,
+      `RPC: ${rpcUrl}. Check connectivity, simulation errors, and binding compatibility.`,
+      error
+    );
+  }
+}
+function readSimulationResult(raw, contractName, method) {
+  if (raw !== null && typeof raw === "object" && "result" in raw) {
+    const result = raw.result;
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  throw new CaatingaError5(
+    `Simulation for "${contractName}.${method}" did not return a result.`,
+    CaatingaErrorCode5.READ_RESULT_MISSING,
+    `Expected "${contractName}.${method}" to expose a simulation result. Use debugRaw to inspect the generated binding output.`
+  );
+}
+
+// src/client/transaction-submit.ts
+import { CaatingaError as CaatingaError6, CaatingaErrorCode as CaatingaErrorCode6 } from "@caatinga/core/browser";
+async function submitTransaction(transaction, signTransaction, contractName, method, rpcUrl) {
+  const candidate = transaction;
+  if (typeof candidate.signAndSend === "function") {
+    try {
+      const raw = await candidate.signAndSend.call(transaction, { signTransaction });
+      assertSubmitResultRecognized(raw, contractName, method);
+      return raw;
+    } catch (error) {
+      if (error instanceof CaatingaError6) {
+        throw error;
+      }
+      throw new CaatingaError6(
+        `Failed to submit XDR for "${contractName}.${method}".`,
+        CaatingaErrorCode6.XDR_SUBMIT_FAILED,
+        `RPC: ${rpcUrl}. Check wallet signature and RPC connectivity.`,
+        error
+      );
+    }
+  }
+  if (typeof candidate.send === "function") {
+    try {
+      const raw = await candidate.send.call(transaction);
+      assertSubmitResultRecognized(raw, contractName, method);
+      return raw;
+    } catch (error) {
+      if (error instanceof CaatingaError6) {
+        throw error;
+      }
+      throw new CaatingaError6(
+        `Failed to submit XDR for "${contractName}.${method}".`,
+        CaatingaErrorCode6.XDR_SUBMIT_FAILED,
+        `RPC: ${rpcUrl}. Check wallet signature and RPC connectivity.`,
+        error
+      );
+    }
+  }
+  throw new CaatingaError6(
+    `Binding transaction for "${contractName}.${method}" cannot be submitted.`,
+    CaatingaErrorCode6.XDR_SUBMIT_FAILED,
+    "Regenerate bindings or provide a compatible binding adapter."
+  );
+}
+function assertSubmitResultRecognized(raw, contractName, method) {
+  if (raw === null || typeof raw !== "object") {
+    return;
+  }
+  const record = raw;
+  const hasTransactionId = "txHash" in record || "transactionHash" in record || "hash" in record || hasNestedSendTransactionResponseHash(record);
+  const hasResult = "result" in record;
+  if (hasTransactionId || hasResult) {
+    return;
+  }
+  throw new CaatingaError6(
+    `Submit returned an unrecognized payload for "${contractName}.${method}".`,
+    CaatingaErrorCode6.XDR_RESULT_FAILED,
+    "Expected txHash, transactionHash, hash, sendTransactionResponse.hash, or result on the submit response. Use debugRaw to inspect the binding output."
+  );
+}
+function hasNestedSendTransactionResponseHash(record) {
+  const response = record.sendTransactionResponse;
+  return response !== null && typeof response === "object" && "hash" in response;
+}
+function normalizeSubmitResult(raw) {
+  const candidate = raw;
+  return {
+    transactionHash: candidate.txHash ?? candidate.transactionHash ?? candidate.hash ?? candidate.sendTransactionResponse?.hash,
+    result: candidate.result
+  };
+}
+
 // src/client/caatinga-contract-client.ts
 var CaatingaContractClient = class {
   constructor(config, contractName, registration, bindingAdapter = createDefaultBindingAdapter(
@@ -152,28 +360,29 @@ var CaatingaContractClient = class {
     let signedXdr;
     const signTransaction = async (xdr2) => {
       try {
-        signedXdr = await this.withWalletTimeout(
+        signedXdr = await withWalletTimeout(
           "signTransaction",
+          this.config.walletTimeout,
           () => this.config.wallet.signTransaction({
             xdr: xdr2,
             networkPassphrase: this.config.network.networkPassphrase
           })
         );
       } catch (error) {
-        if (error instanceof CaatingaError4) {
+        if (error instanceof CaatingaError7) {
           throw error;
         }
-        throw new CaatingaError4(
+        throw new CaatingaError7(
           `Failed to sign XDR for "${this.contractName}.${method}".`,
-          CaatingaErrorCode4.XDR_SIGN_FAILED,
+          CaatingaErrorCode7.XDR_SIGN_FAILED,
           "Connect a wallet and approve the transaction.",
           error
         );
       }
       if (typeof signedXdr !== "string" || signedXdr.trim().length === 0) {
-        throw new CaatingaError4(
+        throw new CaatingaError7(
           `Failed to sign XDR for "${this.contractName}.${method}".`,
-          CaatingaErrorCode4.XDR_SIGN_FAILED,
+          CaatingaErrorCode7.XDR_SIGN_FAILED,
           "Wallet returned an empty or invalid signed XDR. The user may have dismissed the signing prompt.",
           signedXdr
         );
@@ -188,9 +397,9 @@ var CaatingaContractClient = class {
       this.config.network.rpcUrl
     );
     if (typeof transaction.signAndSend === "function" && signedXdr === void 0) {
-      throw new CaatingaError4(
+      throw new CaatingaError7(
         `Failed to sign XDR for "${this.contractName}.${method}".`,
-        CaatingaErrorCode4.XDR_SIGN_FAILED,
+        CaatingaErrorCode7.XDR_SIGN_FAILED,
         "Wallet returned an empty or invalid signed XDR. The generated transaction did not request a wallet signature."
       );
     }
@@ -244,17 +453,18 @@ var CaatingaContractClient = class {
     });
     let publicKey;
     try {
-      publicKey = await this.withWalletTimeout(
+      publicKey = await withWalletTimeout(
         "getPublicKey",
+        this.config.walletTimeout,
         () => this.config.wallet.getPublicKey()
       );
     } catch (error) {
-      if (error instanceof CaatingaError4) {
+      if (error instanceof CaatingaError7) {
         throw error;
       }
-      throw new CaatingaError4(
+      throw new CaatingaError7(
         `Wallet is not connected or the public key is unavailable for "${this.contractName}".`,
-        CaatingaErrorCode4.WALLET_NOT_CONNECTED,
+        CaatingaErrorCode7.WALLET_NOT_CONNECTED,
         "Connect the wallet and grant account access, then retry.",
         error
       );
@@ -268,179 +478,7 @@ var CaatingaContractClient = class {
     const transaction = await this.bindingAdapter.callMethod({ client, method, args });
     return { contractId, transaction };
   }
-  withWalletTimeout(label, fn) {
-    const timeoutMs = this.config.walletTimeout;
-    if (timeoutMs === void 0 || timeoutMs <= 0) {
-      return fn();
-    }
-    let timedOut = false;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        timedOut = true;
-        reject(
-          new CaatingaError4(
-            `Wallet "${label}" timed out after ${timeoutMs}ms.`,
-            CaatingaErrorCode4.WALLET_TIMEOUT,
-            "Ensure the wallet adapter rejects on user dismissal, or increase walletTimeout."
-          )
-        );
-      }, timeoutMs);
-      fn().then(
-        (value) => {
-          if (timedOut) {
-            return;
-          }
-          clearTimeout(timer);
-          resolve(value);
-        },
-        (error) => {
-          if (timedOut) {
-            return;
-          }
-          clearTimeout(timer);
-          reject(error);
-        }
-      );
-    });
-  }
 };
-function splitArgsAndOptions(argsOrOptions, maybeOptions) {
-  return {
-    args: argsOrOptions,
-    debugRaw: maybeOptions?.debugRaw ?? false
-  };
-}
-function splitInvokeArgsAndOptions(argsOrOptions, maybeOptions) {
-  const looksLikeOptions = argsOrOptions !== void 0 && ("debugXdr" in argsOrOptions || "debugRaw" in argsOrOptions) && maybeOptions === void 0;
-  if (looksLikeOptions) {
-    const options = argsOrOptions;
-    return {
-      args: void 0,
-      debugXdr: options.debugXdr ?? false,
-      debugRaw: options.debugRaw ?? false
-    };
-  }
-  return {
-    args: argsOrOptions,
-    debugXdr: maybeOptions?.debugXdr ?? false,
-    debugRaw: maybeOptions?.debugRaw ?? false
-  };
-}
-function splitReadArgsAndOptions(argsOrOptions, maybeOptions) {
-  const looksLikeOptions = argsOrOptions !== void 0 && "debugRaw" in argsOrOptions && maybeOptions === void 0;
-  if (looksLikeOptions) {
-    const options = argsOrOptions;
-    return {
-      args: void 0,
-      debugRaw: options.debugRaw ?? false
-    };
-  }
-  return {
-    args: argsOrOptions,
-    debugRaw: maybeOptions?.debugRaw ?? false
-  };
-}
-async function submitTransaction(transaction, signTransaction, contractName, method, rpcUrl) {
-  const candidate = transaction;
-  if (typeof candidate.signAndSend === "function") {
-    try {
-      const raw = await candidate.signAndSend.call(transaction, { signTransaction });
-      assertSubmitResultRecognized(raw, contractName, method);
-      return raw;
-    } catch (error) {
-      if (error instanceof CaatingaError4) {
-        throw error;
-      }
-      throw new CaatingaError4(
-        `Failed to submit XDR for "${contractName}.${method}".`,
-        CaatingaErrorCode4.XDR_SUBMIT_FAILED,
-        `RPC: ${rpcUrl}. Check wallet signature and RPC connectivity.`,
-        error
-      );
-    }
-  }
-  if (typeof candidate.send === "function") {
-    try {
-      const raw = await candidate.send.call(transaction);
-      assertSubmitResultRecognized(raw, contractName, method);
-      return raw;
-    } catch (error) {
-      if (error instanceof CaatingaError4) {
-        throw error;
-      }
-      throw new CaatingaError4(
-        `Failed to submit XDR for "${contractName}.${method}".`,
-        CaatingaErrorCode4.XDR_SUBMIT_FAILED,
-        `RPC: ${rpcUrl}. Check wallet signature and RPC connectivity.`,
-        error
-      );
-    }
-  }
-  throw new CaatingaError4(
-    `Binding transaction for "${contractName}.${method}" cannot be submitted.`,
-    CaatingaErrorCode4.XDR_SUBMIT_FAILED,
-    "Regenerate bindings or provide a compatible binding adapter."
-  );
-}
-async function prepareReadTransaction(transaction, contractName, method, rpcUrl) {
-  const candidate = transaction;
-  if (typeof candidate.prepare !== "function") {
-    return transaction;
-  }
-  try {
-    return await candidate.prepare.call(transaction);
-  } catch (error) {
-    if (error instanceof CaatingaError4) {
-      throw error;
-    }
-    throw new CaatingaError4(
-      `Failed to prepare XDR for "${contractName}.${method}".`,
-      CaatingaErrorCode4.XDR_PREPARE_FAILED,
-      `RPC: ${rpcUrl}. Check connectivity, simulation errors, and binding compatibility.`,
-      error
-    );
-  }
-}
-function readSimulationResult(raw, contractName, method) {
-  if (raw !== null && typeof raw === "object" && "result" in raw) {
-    const result = raw.result;
-    if (result !== void 0) {
-      return result;
-    }
-  }
-  throw new CaatingaError4(
-    `Simulation for "${contractName}.${method}" did not return a result.`,
-    CaatingaErrorCode4.READ_RESULT_MISSING,
-    `Expected "${contractName}.${method}" to expose a simulation result. Use debugRaw to inspect the generated binding output.`
-  );
-}
-function assertSubmitResultRecognized(raw, contractName, method) {
-  if (raw === null || typeof raw !== "object") {
-    return;
-  }
-  const record = raw;
-  const hasTransactionId = "txHash" in record || "transactionHash" in record || "hash" in record || hasNestedSendTransactionResponseHash(record);
-  const hasResult = "result" in record;
-  if (hasTransactionId || hasResult) {
-    return;
-  }
-  throw new CaatingaError4(
-    `Submit returned an unrecognized payload for "${contractName}.${method}".`,
-    CaatingaErrorCode4.XDR_RESULT_FAILED,
-    "Expected txHash, transactionHash, hash, sendTransactionResponse.hash, or result on the submit response. Use debugRaw to inspect the binding output."
-  );
-}
-function hasNestedSendTransactionResponseHash(record) {
-  const response = record.sendTransactionResponse;
-  return response !== null && typeof response === "object" && "hash" in response;
-}
-function normalizeSubmitResult(raw) {
-  const candidate = raw;
-  return {
-    transactionHash: candidate.txHash ?? candidate.transactionHash ?? candidate.hash ?? candidate.sendTransactionResponse?.hash,
-    result: candidate.result
-  };
-}
 
 // src/client/create-caatinga-client.ts
 function createCaatingaClient(config) {
@@ -448,9 +486,9 @@ function createCaatingaClient(config) {
     contract(contractName) {
       const registration = config.contracts[contractName];
       if (!registration) {
-        throw new CaatingaError5(
+        throw new CaatingaError8(
           `Contract "${contractName}" is not registered.`,
-          CaatingaErrorCode5.CONTRACT_NOT_FOUND,
+          CaatingaErrorCode8.CONTRACT_NOT_FOUND,
           "Add the contract binding to createCaatingaClient()."
         );
       }

package/dist/stellar-wallets-kit.cjs

@@ -20,90 +20,88 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/stellar-wallets-kit.ts
 var stellar_wallets_kit_exports = {};
 __export(stellar_wallets_kit_exports, {
+  WalletNetwork: () => import_stellar_wallets_kit.WalletNetwork,
   createStellarWalletsKitAdapter: () => createStellarWalletsKitAdapter
 });
 module.exports = __toCommonJS(stellar_wallets_kit_exports);
 
 // src/adapters/stellar-wallets-kit.ts
-var import_stellar_wallets_kit = require("stellar-wallets-kit");
+var import_stellar_wallets_kit = require("@creit.tech/stellar-wallets-kit");
+var import_walletconnect = require("@creit.tech/stellar-wallets-kit/modules/walletconnect.module");
 function createStellarWalletsKitAdapter(options = {}) {
+  const network = options.network ?? import_stellar_wallets_kit.WalletNetwork.TESTNET;
   const kit = options.kit ?? new import_stellar_wallets_kit.StellarWalletsKit({
-    network: options.network ?? import_stellar_wallets_kit.WalletNetwork.TESTNET,
-    selectedWallet: options.selectedWallet ?? import_stellar_wallets_kit.WalletType.XBULL
+    network,
+    selectedWalletId: options.selectedWalletId ?? import_stellar_wallets_kit.FREIGHTER_ID,
+    modules: options.modules ?? buildModules(network, options.walletConnectMetadata)
   });
-  let publicKey;
-  let isWalletConnectStarted = false;
-  const sessionDeletedCallbacks = /* @__PURE__ */ new Set();
+  let address;
   return {
     kit,
-    async setWallet(wallet) {
-      await kit.setWallet(wallet);
-      publicKey = void 0;
+    setWallet(walletId) {
+      kit.setWallet(walletId);
+      address = void 0;
     },
-    async setNetwork(network) {
-      await kit.setNetwork(network);
-      publicKey = void 0;
+    getSupportedWallets() {
+      return kit.getSupportedWallets();
     },
-    async getPublicKey() {
-      publicKey = await kit.getPublicKey();
-      return publicKey;
-    },
-    async signTransaction({ xdr, networkPassphrase }) {
-      const walletNetwork = resolveWalletNetwork(networkPassphrase);
-      if (walletNetwork) {
-        await kit.setNetwork(walletNetwork);
-      }
-      const signer = publicKey ?? await kit.getPublicKey();
-      publicKey = signer;
-      const response = await kit.sign({ xdr, publicKey: signer });
-      return response.signedXDR;
-    },
-    async startWalletConnect(metadata = options.walletConnectMetadata) {
-      if (!metadata) {
-        throw new Error("WalletConnect metadata is required before starting WalletConnect.");
-      }
-      await kit.startWalletConnect(metadata);
-      isWalletConnectStarted = true;
-      for (const callback of sessionDeletedCallbacks) {
-        kit.onSessionDeleted((sessionId) => {
-          publicKey = void 0;
-          callback(sessionId);
+    openModal(modalOptions = {}) {
+      return new Promise((resolve, reject) => {
+        void kit.openModal({
+          ...modalOptions.modalTitle ? { modalTitle: modalOptions.modalTitle } : {},
+          ...modalOptions.notAvailableText ? { notAvailableText: modalOptions.notAvailableText } : {},
+          onWalletSelected: (option) => {
+            kit.setWallet(option.id);
+            kit.getAddress().then((result) => {
+              address = result.address;
+              resolve(result.address);
+            }).catch((error) => {
+              reject(error instanceof Error ? error : new Error(String(error)));
+            });
+          },
+          onClosed: (error) => {
+            modalOptions.onClosed?.(error);
+            reject(error);
+          }
         });
-      }
-    },
-    async connectWalletConnect(connectOptions) {
-      await kit.connectWalletConnect(connectOptions);
-      publicKey = void 0;
-    },
-    async getWalletConnectSessions() {
-      return kit.getSessions();
+      });
     },
-    setWalletConnectSession(sessionId) {
-      kit.setSession(sessionId);
-      publicKey = void 0;
+    async getPublicKey() {
+      const result = await kit.getAddress();
+      address = result.address;
+      return result.address;
     },
-    onWalletConnectSessionDeleted(callback) {
-      sessionDeletedCallbacks.add(callback);
-      if (!isWalletConnectStarted) {
-        return;
-      }
-      kit.onSessionDeleted((sessionId) => {
-        publicKey = void 0;
-        callback(sessionId);
+    async signTransaction({ xdr, networkPassphrase }) {
+      const result = await kit.signTransaction(xdr, {
+        networkPassphrase,
+        ...address ? { address } : {}
       });
+      return result.signedTxXdr;
+    },
+    async disconnect() {
+      await kit.disconnect();
+      address = void 0;
     }
   };
 }
-function resolveWalletNetwork(networkPassphrase) {
-  if (networkPassphrase === "Test SDF Network ; September 2015") {
-    return import_stellar_wallets_kit.WalletNetwork.TESTNET;
-  }
-  if (networkPassphrase === "Public Global Stellar Network ; September 2015") {
-    return import_stellar_wallets_kit.WalletNetwork.PUBLIC;
+var HOTWALLET_ID = "hot-wallet";
+function buildModules(network, walletConnectMetadata) {
+  const modules = (0, import_stellar_wallets_kit.allowAllModules)({
+    filterBy: (module2) => module2.productId !== HOTWALLET_ID
+  });
+  if (walletConnectMetadata) {
+    modules.push(
+      new import_walletconnect.WalletConnectModule({
+        ...walletConnectMetadata,
+        network,
+        method: import_walletconnect.WalletConnectAllowedMethods.SIGN
+      })
+    );
   }
-  return void 0;
+  return modules;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  WalletNetwork,
   createStellarWalletsKitAdapter
 });