@talken/talkenkit 2.3.13 → 2.3.15

package/dist/wallets/walletConnectors/chunk-5CCU7PNU.js

@@ -0,0 +1,194 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-H2MX4NAL.js";
+import {
+  createAbcError
+} from "./chunk-UV5HHESJ.js";
+
+// src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
+var TransactionApi = class extends BaseApiClient {
+  /**
+   * Send raw transaction
+   */
+  async sendRawTransaction(chainId, signedTransaction) {
+    const network = this.getNetworkName(chainId);
+    const secureChannelId = await this.secure.getSecureChannelId();
+    const bodyData = {
+      signedSerializeTx: signedTransaction,
+      network
+    };
+    const bodyString = new URLSearchParams(bodyData).toString();
+    const url = "${this.baseURL}${ABC_ENDPOINTS.SEND_RAW_TX}";
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      },
+      body: bodyString
+    });
+    const text = await response.text();
+    if (!text) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from sendRawTx API (status: ${response.status})",
+        { status: response.status }
+      );
+    }
+    const res = JSON.parse(text);
+    if (response.status === 401 && this.refreshToken) {
+      try {
+        await this.refreshAccessToken();
+        const retryResponse = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Secure-Channel": secureChannelId,
+            ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+          },
+          body: bodyString
+        });
+        const retryText = await retryResponse.text();
+        if (!retryText) {
+          throw createAbcError(
+            "NETWORK_ERROR" /* NETWORK_ERROR */,
+            "Empty response after retry (status: ${retryResponse.status})",
+            { status: retryResponse.status }
+          );
+        }
+        const retryRes = JSON.parse(retryText);
+        if (retryRes.item || retryRes.txHash || retryRes.result?.txHash) {
+          const txHash = retryRes.item || retryRes.txHash || retryRes.result.txHash;
+          return { txHash };
+        }
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Failed to send transaction after token refresh",
+          retryRes
+        );
+      } catch (refreshError) {
+        console.error(
+          "Token refresh failed in sendRawTransaction:",
+          refreshError
+        );
+        throw refreshError;
+      }
+    }
+    if (res.result) {
+      if (typeof res.result === "string") {
+        return { txHash: res.result };
+      }
+      if (res.result.txHash) {
+        return { txHash: res.result.txHash };
+      }
+    }
+    if (res.item) {
+      return { txHash: res.item };
+    }
+    if (res.txHash) {
+      return { txHash: res.txHash };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to send transaction",
+      res
+    );
+  }
+  /**
+   * Get transaction count (nonce)
+   */
+  async getTransactionCount(_address, _network, _block = "latest") {
+    const nonceUrl = "${this.baseURL}${ABC_ENDPOINTS.TRANSACTION_COUNT}?address=${address}&network=${network}&block=${block}";
+    const response = await fetch(nonceUrl, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return Number.parseInt(data.result, 16);
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to get transaction count"
+    );
+  }
+  /**
+   * Get suggested gas fees for EIP-1559
+   */
+  async getSuggestedGasFees(_network) {
+    const url = "${this.baseURL}${ABC_ENDPOINTS.GAS_SUGGESTED_FEES}?network=${network}";
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data;
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to get suggested gas fees"
+    );
+  }
+  /**
+   * Estimate gas limit for EIP-1559 transaction
+   */
+  async estimateGas(params) {
+    const estimateBody = new URLSearchParams({
+      network: params.network,
+      to: params.to || "0x",
+      ...params.from ? { from: params.from } : {},
+      ...params.value ? { value: params.value } : {},
+      ...params.data && params.data !== "0x" ? { data: params.data } : {},
+      ...params.maxFeePerGas ? { maxFeePerGas: params.maxFeePerGas } : {},
+      ...params.maxPriorityFeePerGas ? { maxPriorityFeePerGas: params.maxPriorityFeePerGas } : {}
+    });
+    const url = "${this.baseURL}${ABC_ENDPOINTS.GAS_ESTIMATE_EIP1559}";
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      },
+      body: estimateBody.toString()
+    });
+    const data = await response.json();
+    if (response.ok && data.result) {
+      return data.result;
+    }
+    const fallbackGasLimit = "0x2dc6c0";
+    console.warn("\u26A0\uFE0F Gas estimate failed, using fallback:", {
+      error: data.errorMessage || data.msg,
+      fallbackGasLimit
+    });
+    return fallbackGasLimit;
+  }
+  /**
+   * Convert chainId to network name
+   */
+  getNetworkName(chainId) {
+    const networkMap = {
+      1: "ethereum",
+      11155111: "ethereum_sepolia",
+      8217: "klaytn",
+      1001: "klaytn_baobab",
+      137: "polygon",
+      80002: "polygon_amoy",
+      42161: "arbitrum",
+      421614: "arbitrum_sepolia",
+      5e3: "mantle",
+      5003: "mantle_testnet"
+    };
+    return networkMap[chainId] || "ethereum";
+  }
+};
+
+export {
+  TransactionApi
+};

package/dist/wallets/walletConnectors/chunk-5TDZSXJ4.js

@@ -0,0 +1,345 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-H2MX4NAL.js";
+import {
+  createAbcError,
+  loadFromStorage
+} from "./chunk-UV5HHESJ.js";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SigningApi.ts
+import { getAddress } from "viem";
+var SigningApi = class extends BaseApiClient {
+  /**
+   * Sign EVM transaction (EIP-1559)
+   */
+  async signTransaction(params) {
+    this.loadTokens();
+    const wallet = loadFromStorage("wallet" /* WALLET */);
+    if (!wallet) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Wallet information not found in storage"
+      );
+    }
+    const encryptedDevicePassword = await this.secure.getEncryptPlain(
+      wallet.encryptDevicePassword
+    );
+    const encryptedPvencstr = await this.secure.getEncryptPlain(
+      wallet.pvencstr
+    );
+    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
+    const secureChannelId = await this.secure.getSecureChannelId();
+    const network = this.getNetworkName(params.chainId);
+    const tx = params.transaction;
+    const _isContractDeployment = !params.transaction.to || params.transaction.to === "0x" || params.transaction.to === "0x0";
+    const bodyData = {
+      network,
+      encryptDevicePassword: encryptedDevicePassword,
+      pvencstr: encryptedPvencstr,
+      uid: wallet.uid,
+      wid: encryptedWid,
+      sid: getAddress(wallet.address),
+      to: tx.to === "0x" ? "0x" : getAddress(tx.to),
+      type: "EIP1559",
+      ourpubkey: "",
+      ucpubkey: ""
+    };
+    bodyData.from = getAddress(tx.from || wallet.address);
+    if (tx.value) {
+      let hexValue = tx.value.startsWith("0x") ? tx.value.slice(2) : tx.value;
+      if (hexValue.length % 2 !== 0) {
+        hexValue = `0${hexValue}`;
+      }
+      bodyData.value = `0x${hexValue}`;
+    }
+    if (tx.gasLimit || tx.gas) {
+      const gasLimitValue = tx.gasLimit || tx.gas;
+      if (gasLimitValue.toString().startsWith("0x")) {
+        bodyData.gasLimit = gasLimitValue.toString();
+      } else {
+        bodyData.gasLimit = `0x${BigInt(gasLimitValue).toString(16)}`;
+      }
+    }
+    if (tx.maxFeePerGas) {
+      if (tx.maxFeePerGas.toString().startsWith("0x")) {
+        bodyData.maxFeePerGas = tx.maxFeePerGas.toString();
+      } else {
+        bodyData.maxFeePerGas = `0x${BigInt(tx.maxFeePerGas).toString(16)}`;
+      }
+    }
+    if (tx.maxPriorityFeePerGas) {
+      if (tx.maxPriorityFeePerGas.toString().startsWith("0x")) {
+        bodyData.maxPriorityFeePerGas = tx.maxPriorityFeePerGas.toString();
+      } else {
+        bodyData.maxPriorityFeePerGas = `0x${BigInt(tx.maxPriorityFeePerGas).toString(16)}`;
+      }
+    }
+    bodyData.data = tx.data || "0x";
+    const bodyString = new URLSearchParams(bodyData).toString();
+    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TRANSACTION}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: bodyString
+    });
+    const res = await response.json();
+    if (response.status === 401 && this.refreshToken) {
+      await this.refreshAccessToken();
+      const retryResponse = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Secure-Channel": secureChannelId,
+          ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+        },
+        body: bodyString
+      });
+      const retryRes = await retryResponse.json();
+      if (retryRes.serializedTx && retryRes.rawTx) {
+        return {
+          signature: retryRes.serializedTx,
+          txHash: retryRes.rawTx
+        };
+      }
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign transaction after token refresh",
+        retryRes
+      );
+    }
+    if (res.serializedTx && res.rawTx) {
+      return {
+        signature: res.serializedTx,
+        txHash: res.rawTx
+      };
+    }
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "Failed to sign transaction",
+      res
+    );
+  }
+  /**
+   * Sign message (Personal Sign - EIP-191)
+   */
+  async signMessage(params) {
+    this.loadTokens();
+    const wallet = loadFromStorage("wallet" /* WALLET */);
+    if (!wallet) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Wallet information not found in storage"
+      );
+    }
+    const ethers = await import("ethers");
+    const messageHash = ethers.utils.hashMessage(params.message);
+    const hash = messageHash.startsWith("0x") ? messageHash.slice(2) : messageHash;
+    const encryptedDevicePassword = await this.secure.getEncryptPlain(
+      wallet.encryptDevicePassword
+    );
+    const encryptedPvencstr = await this.secure.getEncryptPlain(
+      wallet.pvencstr
+    );
+    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
+    const secureChannelId = await this.secure.getSecureChannelId();
+    const bodyData = {
+      hash,
+      encryptDevicePassword: encryptedDevicePassword,
+      pvencstr: encryptedPvencstr,
+      wid: encryptedWid,
+      uid: wallet.uid,
+      sid: wallet.sid
+    };
+    const bodyString = new URLSearchParams(bodyData).toString();
+    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_HASH}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: bodyString
+    });
+    const text = await response.text();
+    if (!text) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        `Empty response from sign API (status: ${response.status})`,
+        { status: response.status }
+      );
+    }
+    const res = JSON.parse(text);
+    if (response.status === 401) {
+      if (!this.refreshToken) {
+        this.loadTokens();
+      }
+      if (this.refreshToken) {
+        await this.refreshAccessToken();
+        const retryResponse = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Secure-Channel": secureChannelId,
+            ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+          },
+          body: bodyString
+        });
+        const retryText = await retryResponse.text();
+        if (!retryText) {
+          throw createAbcError(
+            "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+            `Empty response from retry (status: ${retryResponse.status})`,
+            { status: retryResponse.status }
+          );
+        }
+        const retryRes = JSON.parse(retryText);
+        if (retryRes.status === "success" && retryRes.result?.signstr) {
+          return { signature: retryRes.result.signstr };
+        }
+        throw createAbcError(
+          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+          "Failed to sign message after token refresh",
+          retryRes
+        );
+      }
+    }
+    if (res.signstr) {
+      const signData = JSON.parse(res.signstr);
+      const sigList = signData.sig_list?.[0];
+      if (!sigList || !sigList.r || !sigList.s) {
+        throw createAbcError(
+          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+          "Invalid signature format",
+          res
+        );
+      }
+      const v = (sigList.vsource || 0) + 27;
+      const signature = sigList.r + sigList.s.slice(2) + v.toString(16).padStart(2, "0");
+      return { signature };
+    }
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "Failed to sign message",
+      res
+    );
+  }
+  /**
+   * Sign typed data (EIP-712)
+   */
+  async signTypedData(params) {
+    const wallet = loadFromStorage("wallet" /* WALLET */);
+    if (!wallet) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        "Wallet information not found in storage"
+      );
+    }
+    const encryptedDevicePassword = await this.secure.getEncryptPlain(
+      wallet.encryptDevicePassword
+    );
+    const encryptedPvencstr = await this.secure.getEncryptPlain(
+      wallet.pvencstr
+    );
+    const encryptedWid = await this.secure.getEncryptPlain(wallet.wid);
+    const secureChannelId = await this.secure.getSecureChannelId();
+    const network = this.getNetworkName(wallet.chainId);
+    const bodyData = {
+      messageJson: params.typedData,
+      version: "v4",
+      network,
+      encryptDevicePassword: encryptedDevicePassword,
+      pvencstr: encryptedPvencstr,
+      wid: encryptedWid,
+      uid: wallet.uid,
+      sid: wallet.sid
+    };
+    const bodyString = new URLSearchParams(bodyData).toString();
+    const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TYPED}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+      },
+      body: bodyString
+    });
+    const text = await response.text();
+    if (!text) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        `Empty response from signTypedData API (status: ${response.status})`,
+        { status: response.status }
+      );
+    }
+    const res = JSON.parse(text);
+    if (response.status === 401 && this.refreshToken) {
+      await this.refreshAccessToken();
+      const retryResponse = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Secure-Channel": secureChannelId,
+          ...this.accessToken ? { Authorization: `Bearer ${this.accessToken}` } : {}
+        },
+        body: bodyString
+      });
+      const retryText = await retryResponse.text();
+      if (!retryText) {
+        throw createAbcError(
+          "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+          `Empty response after retry (status: ${retryResponse.status})`,
+          { status: retryResponse.status }
+        );
+      }
+      const retryRes = JSON.parse(retryText);
+      if (retryRes.serializedTx) {
+        return { signature: retryRes.serializedTx };
+      }
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign typed data after token refresh",
+        retryRes
+      );
+    }
+    if (res.serializedTx) {
+      return { signature: res.serializedTx };
+    }
+    throw createAbcError(
+      "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+      "Failed to sign typed data",
+      res
+    );
+  }
+  /**
+   * Convert chainId to network name
+   */
+  getNetworkName(chainId) {
+    const networkMap = {
+      1: "ethereum",
+      11155111: "ethereum_sepolia",
+      8217: "klaytn",
+      1001: "klaytn_baobab",
+      137: "polygon",
+      80002: "polygon_amoy",
+      42161: "arbitrum",
+      421614: "arbitrum_sepolia",
+      5e3: "mantle",
+      5003: "mantle_testnet"
+    };
+    return networkMap[chainId] || "ethereum";
+  }
+};
+
+export {
+  SigningApi
+};

package/dist/wallets/walletConnectors/{chunk-4YKA5OIT.js → chunk-75RN2RLT.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   WalletApi
-} from "./chunk-F5Q4VDER.js";
+} from "./chunk-EGOIRXTV.js";
 import {
   TransactionApi
 } from "./chunk-ISAMATTH.js";
@@ -11,12 +11,12 @@ import {
 import {
   AuthApi
 } from "./chunk-YEHCPL4R.js";
-import {
-  SigningApi
-} from "./chunk-V3XKL7AD.js";
 import {
   SolanaApi
-} from "./chunk-SGLHM6AU.js";
+} from "./chunk-7DEZCGNV.js";
+import {
+  SigningApi
+} from "./chunk-KKPINUPY.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {

package/dist/wallets/walletConnectors/{chunk-JXPLBYVW.js → chunk-7DEZCGNV.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-NX5MQHSQ.js";
 import {
   getSolanaNetwork
-} from "./chunk-AL7R7JQU.js";
+} from "./chunk-A7FIBI6X.js";
 import {
   createAbcError
 } from "./chunk-UV5HHESJ.js";

package/dist/wallets/walletConnectors/{chunk-ZX6LABEF.js → chunk-A7FIBI6X.js}

@@ -34,27 +34,42 @@ var DEFAULT_NETWORK_CONFIG = {
     testnet: "bitcoin_testnet" /* Testnet */
   }
 };
-function getEnvironment() {
-  if (typeof process === "undefined") {
-    return "development";
-  }
-  const env = process.env.NEXT_PUBLIC_ENVIRONMENT;
-  return env === "production" ? "production" : "development";
+var globalDefaultChainId;
+var globalDefaultSolanaNetwork;
+var globalDefaultBitcoinNetwork;
+function setGlobalDefaultChainId(chainId) {
+  globalDefaultChainId = chainId;
+}
+function setGlobalDefaultSolanaNetwork(network) {
+  globalDefaultSolanaNetwork = network;
+}
+function setGlobalDefaultBitcoinNetwork(network) {
+  globalDefaultBitcoinNetwork = network;
 }
 function getEvmNetwork(customChainId) {
   if (customChainId !== void 0) {
     return customChainId;
   }
-  const environment = getEnvironment();
-  return environment === "production" ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
+  if (globalDefaultChainId !== void 0) {
+    return globalDefaultChainId;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  const fallbackChainId = isProduction ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
+  return fallbackChainId;
 }
 function getSolanaNetwork() {
-  const environment = getEnvironment();
-  return environment === "production" ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
+  if (globalDefaultSolanaNetwork !== void 0) {
+    return globalDefaultSolanaNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
 }
 function getBitcoinNetwork() {
-  const environment = getEnvironment();
-  return environment === "production" ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+  if (globalDefaultBitcoinNetwork !== void 0) {
+    return globalDefaultBitcoinNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
 }
 function getNetworkForChain(chainType) {
   switch (chainType) {
@@ -117,7 +132,9 @@ export {
   SolanaNetwork,
   BitcoinNetwork,
   DEFAULT_NETWORK_CONFIG,
-  getEnvironment,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork,
+  setGlobalDefaultBitcoinNetwork,
   getEvmNetwork,
   getSolanaNetwork,
   getBitcoinNetwork,

package/dist/wallets/walletConnectors/{chunk-2E2TVL4A.js → chunk-AVPBPELO.js}

@@ -1,22 +1,22 @@
 "use client";
 import {
   TransactionApi
-} from "./chunk-FGBDWBWQ.js";
+} from "./chunk-5CCU7PNU.js";
 import {
   WalletApi
-} from "./chunk-DPL5VRGJ.js";
+} from "./chunk-EEY5CXKO.js";
 import {
   AuthApi
-} from "./chunk-MZOFZ2NQ.js";
+} from "./chunk-G7PEFBL6.js";
 import {
   BitcoinApi
-} from "./chunk-BNSBK5PQ.js";
+} from "./chunk-F5P2INHS.js";
 import {
   SigningApi
-} from "./chunk-KZG5KU7A.js";
+} from "./chunk-5TDZSXJ4.js";
 import {
   SolanaApi
-} from "./chunk-A7KV643A.js";
+} from "./chunk-QI2VB7LL.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {