@caatinga/client 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/artifacts/resolve-contract-id.ts
-import { CaatingaError, CaatingaErrorCode } from "@caatinga/core";
+import { CaatingaError, CaatingaErrorCode } from "@caatinga/core/browser";
 function resolveContractId(input) {
   if (input.explicitContractId) {
     return input.explicitContractId;
@@ -16,7 +16,7 @@ function resolveContractId(input) {
 }
 
 // src/bindings/default-binding-adapter.ts
-import { CaatingaError as CaatingaError2, CaatingaErrorCode as CaatingaErrorCode2 } from "@caatinga/core";
+import { CaatingaError as CaatingaError2, CaatingaErrorCode as CaatingaErrorCode2 } from "@caatinga/core/browser";
 function createDefaultBindingAdapter(binding) {
   return {
     createClient({ contractId, publicKey, rpcUrl, networkPassphrase }) {
@@ -50,13 +50,13 @@ function createDefaultBindingAdapter(binding) {
 }
 
 // src/client/create-caatinga-client.ts
-import { CaatingaError as CaatingaError5, CaatingaErrorCode as CaatingaErrorCode5 } from "@caatinga/core";
+import { CaatingaError as CaatingaError5, CaatingaErrorCode as CaatingaErrorCode5 } from "@caatinga/core/browser";
 
 // src/client/caatinga-contract-client.ts
-import { CaatingaError as CaatingaError4, CaatingaErrorCode as CaatingaErrorCode4 } from "@caatinga/core";
+import { CaatingaError as CaatingaError4, CaatingaErrorCode as CaatingaErrorCode4 } from "@caatinga/core/browser";
 
 // src/xdr/build-xdr.ts
-import { CaatingaError as CaatingaError3, CaatingaErrorCode as CaatingaErrorCode3 } from "@caatinga/core";
+import { CaatingaError as CaatingaError3, CaatingaErrorCode as CaatingaErrorCode3 } from "@caatinga/core/browser";
 async function buildXdr(input) {
   try {
     const transaction = input.transaction;
@@ -72,7 +72,7 @@ async function buildXdr(input) {
         throw new CaatingaError3(
           `Failed to prepare XDR for "${input.contractName}.${input.method}".`,
           CaatingaErrorCode3.XDR_PREPARE_FAILED,
-          "Check RPC connectivity, simulation errors, and binding compatibility.",
+          `RPC: ${input.rpcUrl}. Check connectivity, simulation errors, and binding compatibility.`,
           error
         );
       }
@@ -134,6 +134,7 @@ var CaatingaContractClient = class {
       method,
       contractId,
       transaction,
+      rpcUrl: this.config.network.rpcUrl,
       debug: debugRaw
     });
   }
@@ -145,23 +146,54 @@ var CaatingaContractClient = class {
       method,
       contractId,
       transaction,
+      rpcUrl: this.config.network.rpcUrl,
       debug: debugRaw
     });
     let signedXdr;
-    try {
-      signedXdr = await this.config.wallet.signTransaction({
-        xdr: xdr.preparedXdr,
-        networkPassphrase: this.config.network.networkPassphrase
-      });
-    } catch (error) {
+    const signTransaction = async (xdr2) => {
+      try {
+        signedXdr = await this.withWalletTimeout(
+          "signTransaction",
+          () => this.config.wallet.signTransaction({
+            xdr: xdr2,
+            networkPassphrase: this.config.network.networkPassphrase
+          })
+        );
+      } catch (error) {
+        if (error instanceof CaatingaError4) {
+          throw error;
+        }
+        throw new CaatingaError4(
+          `Failed to sign XDR for "${this.contractName}.${method}".`,
+          CaatingaErrorCode4.XDR_SIGN_FAILED,
+          "Connect a wallet and approve the transaction.",
+          error
+        );
+      }
+      if (typeof signedXdr !== "string" || signedXdr.trim().length === 0) {
+        throw new CaatingaError4(
+          `Failed to sign XDR for "${this.contractName}.${method}".`,
+          CaatingaErrorCode4.XDR_SIGN_FAILED,
+          "Wallet returned an empty or invalid signed XDR. The user may have dismissed the signing prompt.",
+          signedXdr
+        );
+      }
+      return { signedTxXdr: signedXdr };
+    };
+    const raw = await submitTransaction(
+      transaction,
+      signTransaction,
+      this.contractName,
+      method,
+      this.config.network.rpcUrl
+    );
+    if (typeof transaction.signAndSend === "function" && signedXdr === void 0) {
       throw new CaatingaError4(
         `Failed to sign XDR for "${this.contractName}.${method}".`,
         CaatingaErrorCode4.XDR_SIGN_FAILED,
-        "Connect a wallet and approve the transaction.",
-        error
+        "Wallet returned an empty or invalid signed XDR. The generated transaction did not request a wallet signature."
       );
     }
-    const raw = await submitTransaction(transaction, signedXdr, this.contractName, method);
     const normalized = normalizeSubmitResult(raw);
     return {
       status: "confirmed",
@@ -174,12 +206,35 @@ var CaatingaContractClient = class {
         xdr: {
           unsigned: xdr.unsignedXdr,
           prepared: xdr.preparedXdr,
-          signed: signedXdr
+          ...signedXdr ? { signed: signedXdr } : {}
         }
       } : {},
       ...debugRaw ? { raw } : {}
     };
   }
+  async simulate(method, argsOrOptions, maybeOptions) {
+    const { args, debugRaw } = splitReadArgsAndOptions(argsOrOptions, maybeOptions);
+    const { contractId, transaction } = await this.createTransaction(method, args);
+    const raw = await prepareReadTransaction(
+      transaction,
+      this.contractName,
+      method,
+      this.config.network.rpcUrl
+    );
+    const result = readSimulationResult(raw, this.contractName, method);
+    return {
+      status: "simulated",
+      contract: this.contractName,
+      method,
+      contractId,
+      result,
+      ...debugRaw ? { raw } : {}
+    };
+  }
+  async read(method, argsOrOptions, maybeOptions) {
+    const result = await this.simulate(method, argsOrOptions, maybeOptions);
+    return result.result;
+  }
   async createTransaction(method, args) {
     const contractId = resolveContractId({
       artifacts: this.config.artifacts,
@@ -189,7 +244,10 @@ var CaatingaContractClient = class {
     });
     let publicKey;
     try {
-      publicKey = await this.config.wallet.getPublicKey();
+      publicKey = await this.withWalletTimeout(
+        "getPublicKey",
+        () => this.config.wallet.getPublicKey()
+      );
     } catch (error) {
       if (error instanceof CaatingaError4) {
         throw error;
@@ -210,6 +268,41 @@ 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 {
@@ -233,38 +326,100 @@ function splitInvokeArgsAndOptions(argsOrOptions, maybeOptions) {
     debugRaw: maybeOptions?.debugRaw ?? false
   };
 }
-async function submitTransaction(transaction, signedXdr, contractName, method) {
+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;
-  const submit = candidate.signAndSend ?? candidate.send;
-  if (typeof submit !== "function") {
-    throw new CaatingaError4(
-      `Binding transaction for "${contractName}.${method}" cannot be submitted.`,
-      CaatingaErrorCode4.XDR_SUBMIT_FAILED,
-      "Regenerate bindings or provide a compatible binding adapter."
-    );
+  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 {
-    const raw = await submit.call(transaction, { signedXdr });
-    assertSubmitResultRecognized(raw, contractName, method);
-    return raw;
+    return await candidate.prepare.call(transaction);
   } catch (error) {
     if (error instanceof CaatingaError4) {
       throw error;
     }
     throw new CaatingaError4(
-      `Failed to submit XDR for "${contractName}.${method}".`,
-      CaatingaErrorCode4.XDR_SUBMIT_FAILED,
-      "Check wallet signature and RPC connectivity.",
+      `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;
+  const hasTransactionId = "txHash" in record || "transactionHash" in record || "hash" in record || hasNestedSendTransactionResponseHash(record);
   const hasResult = "result" in record;
   if (hasTransactionId || hasResult) {
     return;
@@ -272,13 +427,17 @@ function assertSubmitResultRecognized(raw, contractName, method) {
   throw new CaatingaError4(
     `Submit returned an unrecognized payload for "${contractName}.${method}".`,
     CaatingaErrorCode4.XDR_RESULT_FAILED,
-    "Expected txHash, transactionHash, hash, or result on the submit response. Use debugRaw to inspect the binding output."
+    "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,
+    transactionHash: candidate.txHash ?? candidate.transactionHash ?? candidate.hash ?? candidate.sendTransactionResponse?.hash,
     result: candidate.result
   };
 }

package/dist/stellar-wallets-kit.cjs

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/stellar-wallets-kit.ts
+var stellar_wallets_kit_exports = {};
+__export(stellar_wallets_kit_exports, {
+  createStellarWalletsKitAdapter: () => createStellarWalletsKitAdapter
+});
+module.exports = __toCommonJS(stellar_wallets_kit_exports);
+
+// src/adapters/stellar-wallets-kit.ts
+var import_stellar_wallets_kit = require("stellar-wallets-kit");
+function createStellarWalletsKitAdapter(options = {}) {
+  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
+  });
+  let publicKey;
+  let isWalletConnectStarted = false;
+  const sessionDeletedCallbacks = /* @__PURE__ */ new Set();
+  return {
+    kit,
+    async setWallet(wallet) {
+      await kit.setWallet(wallet);
+      publicKey = void 0;
+    },
+    async setNetwork(network) {
+      await kit.setNetwork(network);
+      publicKey = void 0;
+    },
+    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);
+        });
+      }
+    },
+    async connectWalletConnect(connectOptions) {
+      await kit.connectWalletConnect(connectOptions);
+      publicKey = void 0;
+    },
+    async getWalletConnectSessions() {
+      return kit.getSessions();
+    },
+    setWalletConnectSession(sessionId) {
+      kit.setSession(sessionId);
+      publicKey = void 0;
+    },
+    onWalletConnectSessionDeleted(callback) {
+      sessionDeletedCallbacks.add(callback);
+      if (!isWalletConnectStarted) {
+        return;
+      }
+      kit.onSessionDeleted((sessionId) => {
+        publicKey = void 0;
+        callback(sessionId);
+      });
+    }
+  };
+}
+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;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStellarWalletsKitAdapter
+});

package/dist/stellar-wallets-kit.d.cts

@@ -0,0 +1,46 @@
+import { StellarWalletsKit, WalletType, WalletNetwork, IConnectWalletConnectParams } from 'stellar-wallets-kit';
+import { C as CaatingaWalletAdapter } from './types-D4XEyX4J.cjs';
+import '@caatinga/core/browser';
+
+interface StellarWalletsKitMetadata {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+    projectId: string;
+}
+interface StellarWalletsKitAdapterOptions {
+    kit?: StellarWalletsKit;
+    network?: WalletNetwork;
+    selectedWallet?: WalletType;
+    walletConnectMetadata?: StellarWalletsKitMetadata;
+}
+interface StellarWalletsKitConnectOptions {
+    chains?: IConnectWalletConnectParams["chains"];
+    methods?: IConnectWalletConnectParams["methods"];
+    pairingTopic?: IConnectWalletConnectParams["pairingTopic"];
+}
+interface StellarWalletsKitSession {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    icons: string;
+    accounts: Array<{
+        network: "pubnet" | "testnet";
+        publicKey: string;
+    }>;
+}
+interface StellarWalletsKitAdapter extends CaatingaWalletAdapter {
+    kit: StellarWalletsKit;
+    setWallet(wallet: WalletType): Promise<void>;
+    setNetwork(network: WalletNetwork): Promise<void>;
+    startWalletConnect(metadata?: StellarWalletsKitMetadata): Promise<void>;
+    connectWalletConnect(options?: StellarWalletsKitConnectOptions): Promise<void>;
+    getWalletConnectSessions(): Promise<StellarWalletsKitSession[]>;
+    setWalletConnectSession(sessionId: string): void;
+    onWalletConnectSessionDeleted(callback: (sessionId: string) => void): void;
+}
+declare function createStellarWalletsKitAdapter(options?: StellarWalletsKitAdapterOptions): StellarWalletsKitAdapter;
+
+export { type StellarWalletsKitAdapter, type StellarWalletsKitAdapterOptions, type StellarWalletsKitConnectOptions, type StellarWalletsKitMetadata, type StellarWalletsKitSession, createStellarWalletsKitAdapter };

package/dist/stellar-wallets-kit.d.ts

@@ -0,0 +1,46 @@
+import { StellarWalletsKit, WalletType, WalletNetwork, IConnectWalletConnectParams } from 'stellar-wallets-kit';
+import { C as CaatingaWalletAdapter } from './types-D4XEyX4J.js';
+import '@caatinga/core/browser';
+
+interface StellarWalletsKitMetadata {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+    projectId: string;
+}
+interface StellarWalletsKitAdapterOptions {
+    kit?: StellarWalletsKit;
+    network?: WalletNetwork;
+    selectedWallet?: WalletType;
+    walletConnectMetadata?: StellarWalletsKitMetadata;
+}
+interface StellarWalletsKitConnectOptions {
+    chains?: IConnectWalletConnectParams["chains"];
+    methods?: IConnectWalletConnectParams["methods"];
+    pairingTopic?: IConnectWalletConnectParams["pairingTopic"];
+}
+interface StellarWalletsKitSession {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    icons: string;
+    accounts: Array<{
+        network: "pubnet" | "testnet";
+        publicKey: string;
+    }>;
+}
+interface StellarWalletsKitAdapter extends CaatingaWalletAdapter {
+    kit: StellarWalletsKit;
+    setWallet(wallet: WalletType): Promise<void>;
+    setNetwork(network: WalletNetwork): Promise<void>;
+    startWalletConnect(metadata?: StellarWalletsKitMetadata): Promise<void>;
+    connectWalletConnect(options?: StellarWalletsKitConnectOptions): Promise<void>;
+    getWalletConnectSessions(): Promise<StellarWalletsKitSession[]>;
+    setWalletConnectSession(sessionId: string): void;
+    onWalletConnectSessionDeleted(callback: (sessionId: string) => void): void;
+}
+declare function createStellarWalletsKitAdapter(options?: StellarWalletsKitAdapterOptions): StellarWalletsKitAdapter;
+
+export { type StellarWalletsKitAdapter, type StellarWalletsKitAdapterOptions, type StellarWalletsKitConnectOptions, type StellarWalletsKitMetadata, type StellarWalletsKitSession, createStellarWalletsKitAdapter };

package/dist/stellar-wallets-kit.js

@@ -0,0 +1,86 @@
+// src/adapters/stellar-wallets-kit.ts
+import {
+  StellarWalletsKit,
+  WalletNetwork,
+  WalletType
+} from "stellar-wallets-kit";
+function createStellarWalletsKitAdapter(options = {}) {
+  const kit = options.kit ?? new StellarWalletsKit({
+    network: options.network ?? WalletNetwork.TESTNET,
+    selectedWallet: options.selectedWallet ?? WalletType.XBULL
+  });
+  let publicKey;
+  let isWalletConnectStarted = false;
+  const sessionDeletedCallbacks = /* @__PURE__ */ new Set();
+  return {
+    kit,
+    async setWallet(wallet) {
+      await kit.setWallet(wallet);
+      publicKey = void 0;
+    },
+    async setNetwork(network) {
+      await kit.setNetwork(network);
+      publicKey = void 0;
+    },
+    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);
+        });
+      }
+    },
+    async connectWalletConnect(connectOptions) {
+      await kit.connectWalletConnect(connectOptions);
+      publicKey = void 0;
+    },
+    async getWalletConnectSessions() {
+      return kit.getSessions();
+    },
+    setWalletConnectSession(sessionId) {
+      kit.setSession(sessionId);
+      publicKey = void 0;
+    },
+    onWalletConnectSessionDeleted(callback) {
+      sessionDeletedCallbacks.add(callback);
+      if (!isWalletConnectStarted) {
+        return;
+      }
+      kit.onSessionDeleted((sessionId) => {
+        publicKey = void 0;
+        callback(sessionId);
+      });
+    }
+  };
+}
+function resolveWalletNetwork(networkPassphrase) {
+  if (networkPassphrase === "Test SDF Network ; September 2015") {
+    return WalletNetwork.TESTNET;
+  }
+  if (networkPassphrase === "Public Global Stellar Network ; September 2015") {
+    return WalletNetwork.PUBLIC;
+  }
+  return void 0;
+}
+export {
+  createStellarWalletsKitAdapter
+};