@talken/talkenkit 2.4.16 → 2.4.18

package/dist/wallets/walletConnectors/chunk-IX6DQDRE.js

@@ -0,0 +1,107 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-7ZCM4DCC.js";
+
+// src/wallets/walletConnectors/abcWallet/api/GasApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var GasApi = class extends BaseApiClient {
+  parseGasFees(data) {
+    return {
+      ...data,
+      networkCongestion: data.networkCongestion != null ? Number(data.networkCongestion) : void 0
+    };
+  }
+  /**
+   * Get suggested gas fees for EIP-1559 transactions via TalkenApiClient
+   *
+   * @param network - Network name (ethereum, polygon, klaytn, etc.)
+   * @returns Suggested gas fees or null if failed
+   */
+  async getSuggestedGasFees(network) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      const gasFees = await api.evm.getGasSuggested(network);
+      return this.parseGasFees(gasFees);
+    } catch (error) {
+      console.warn(
+        "[GasApi] TalkenApi getGasSuggested failed:",
+        network,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Estimate gas limit for EIP-1559 transaction via TalkenApiClient
+   *
+   * @param params - Transaction parameters
+   * @returns Gas limit (hex string) or null if failed
+   */
+  async estimateGas(params) {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    try {
+      const response = await api.evm.estimateGas({
+        network: params.network,
+        from: params.from || "",
+        to: params.to,
+        value: params.value || "0x0",
+        data: params.data || "0x"
+      });
+      return response.result ?? null;
+    } catch (error) {
+      console.warn("[GasApi] TalkenApi estimateGas failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Get suggested gas fees with timeout
+   *
+   * @param network - Network name
+   * @param timeoutMs - Timeout in milliseconds (default: 5000)
+   * @returns Suggested gas fees or null if timeout/failed
+   */
+  async getSuggestedGasFeesWithTimeout(network, timeoutMs = 5e3) {
+    try {
+      const result = await Promise.race([
+        this.getSuggestedGasFees(network),
+        new Promise(
+          (resolve) => setTimeout(() => resolve(null), timeoutMs)
+        )
+      ]);
+      return result;
+    } catch (_error) {
+      console.warn("[GasApi] Gas fees request timed out:", network);
+      return null;
+    }
+  }
+  /**
+   * Estimate gas with timeout
+   *
+   * @param params - Transaction parameters
+   * @param timeoutMs - Timeout in milliseconds (default: 5000)
+   * @returns Gas limit (hex string) or null if timeout/failed
+   */
+  async estimateGasWithTimeout(params, timeoutMs = 5e3) {
+    try {
+      const result = await Promise.race([
+        this.estimateGas(params),
+        new Promise(
+          (resolve) => setTimeout(() => resolve(null), timeoutMs)
+        )
+      ]);
+      return result;
+    } catch (_error) {
+      console.warn("[GasApi] Gas estimate request timed out");
+      return null;
+    }
+  }
+};
+
+export {
+  GasApi
+};

package/dist/wallets/walletConnectors/{chunk-YCZ4CZQ6.js → chunk-IXEXMODE.js}

@@ -2,7 +2,7 @@
 import {
   loadAuthState,
   saveAuthState
-} from "./chunk-TYUEB4VT.js";
+} from "./chunk-6LH6ZME2.js";
 
 // src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
 var AbcBitcoinConnector = class {
@@ -65,19 +65,11 @@ var AbcBitcoinConnector = class {
       }
       this.wallet = authState.bitcoinWallet;
       this.provider.setWallet(authState.bitcoinWallet);
-      this.provider.setRequestPinCallback(async () => {
-        if (!authState.pin) {
-          console.error("[BitcoinConnector] \u274C PIN not available in authState");
-          throw new Error("PIN not available");
-        }
-        return authState.pin;
-      });
-      console.log("[BitcoinConnector] \u2705 Wallet and PIN callback set:", {
+      console.log("[BitcoinConnector] \u2705 Wallet set:", {
         address: authState.bitcoinWallet.address,
         publicKey: authState.bitcoinWallet.publicKey,
         addressType: authState.bitcoinWallet.addressType,
-        network: authState.bitcoinWallet.network,
-        hasPIN: !!authState.pin
+        network: authState.bitcoinWallet.network
       });
       this.connected = true;
       return {

package/dist/wallets/walletConnectors/{chunk-XHOWI6QG.js → chunk-KBSO4UER.js}

@@ -1,6 +1,7 @@
 "use client";
 
 // src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
 var EventEmitter = class {
   constructor() {
     this.events = /* @__PURE__ */ new Map();
@@ -65,7 +66,6 @@ var AbcSolanaProvider = class extends EventEmitter {
     super();
     this.wallet = null;
     this.connected = false;
-    this.requestPinCallback = null;
     this.client = client;
   }
   /**
@@ -93,10 +93,11 @@ var AbcSolanaProvider = class extends EventEmitter {
     this.emit("accountsChanged", []);
   }
   /**
-   * Set PIN request callback for transaction signing
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, native SOL transfers will use a single API call instead of multi-step WaaS
    */
-  setRequestPinCallback(callback) {
-    this.requestPinCallback = callback;
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
   }
   /**
    * Check if connected
@@ -162,71 +163,42 @@ var AbcSolanaProvider = class extends EventEmitter {
     }
   }
   /**
-   * Sign Solana transaction (not used - ABC WaaS handles signing server-side)
-   * This method is kept for compatibility but not recommended for direct use
-   * Use the high-level sendTransaction() flow instead
+   * Sign arbitrary Solana transaction (requires PIN)
+   * Supports both Legacy Transaction and VersionedTransaction
+   * Used for custom transactions, dApp interactions, and protocol integrations
    */
-  async signTransaction(_transaction, _params) {
-    throw new SolanaProviderError(
-      SolanaErrorCode.UNSUPPORTED_METHOD,
-      "Direct transaction signing not supported. Use useSolanaWallet.sendTransaction() which handles the full flow via ABC WaaS API."
-    );
-  }
-  /**
-   * Send Solana transaction (with PIN verification)
-   */
-  async sendTransaction(params) {
+  async signTransaction(transaction) {
     if (!this.wallet) {
       throw new SolanaProviderError(
         SolanaErrorCode.DISCONNECTED,
         "Wallet not connected"
       );
     }
-    if (!this.requestPinCallback) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.UNAUTHORIZED,
-        "PIN callback not set"
-      );
-    }
     try {
-      const pin = await this.requestPinCallback();
-      const encoder = new TextEncoder();
-      const data = encoder.encode(pin);
-      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      const pinHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-      const storedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
-      if (storedPinHash && pinHash !== storedPinHash) {
-        throw new SolanaProviderError(
-          SolanaErrorCode.UNAUTHORIZED,
-          "Incorrect PIN"
-        );
+      const { VersionedTransaction, PublicKey } = await import("@solana/web3.js");
+      const isVersioned = transaction instanceof VersionedTransaction;
+      let serialized;
+      if (isVersioned) {
+        serialized = transaction.message.serialize();
+      } else {
+        serialized = transaction.serializeMessage();
       }
-      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
-      const network = this.wallet.network || "solana_devnet";
-      const amountLamports = params.amount * LAMPORTS_PER_SOL;
-      const txGenResponse = await this.client.solana.generateTransferTransaction({
-        network,
-        amount: amountLamports,
-        fromAddress: this.wallet.address,
-        toAddress: params.toAddress,
-        feePayerAddress: this.wallet.address
-      });
+      const messageHex = Buffer.from(serialized).toString("hex");
       const signatureResponse = await this.client.solana.signSolanaTransaction({
         keyId: this.wallet.keyId,
         encryptedShare: this.wallet.encryptedShare,
         secretStore: this.wallet.secretStore || "",
-        message: txGenResponse.serialized_tx
-      });
-      const result = await this.client.solana.sendSolanaTransaction({
-        network,
-        serializedTX: txGenResponse.serialized_tx,
-        signatures: [signatureResponse.signature]
+        message: messageHex
       });
-      return {
-        signature: result.txHash,
-        serializedTx: txGenResponse.serialized_tx
-      };
+      const signatureHex = signatureResponse.signature.startsWith("0x") ? signatureResponse.signature.slice(2) : signatureResponse.signature;
+      const signatureBytes = Buffer.from(signatureHex, "hex");
+      const publicKey = new PublicKey(this.wallet.address);
+      if (isVersioned) {
+        transaction.addSignature(publicKey, signatureBytes);
+      } else {
+        transaction.addSignature(publicKey, signatureBytes);
+      }
+      return transaction;
     } catch (error) {
       if (error.code === 4001 || error.cancelled) {
         throw error;
@@ -234,115 +206,116 @@ var AbcSolanaProvider = class extends EventEmitter {
       this.emit("error", error);
       throw new SolanaProviderError(
         SolanaErrorCode.INTERNAL_ERROR,
-        "Failed to send transaction",
+        "Failed to sign transaction",
         error
       );
     }
   }
   /**
-   * Get wallet info
+   * Sign multiple transactions (batch signing)
    */
-  getWalletInfo() {
-    if (!this.wallet)
-      return null;
-    return {
-      address: this.wallet.address,
-      publicKey: this.wallet.publicKey,
-      network: this.wallet.network
-    };
+  async signAllTransactions(transactions) {
+    const signedTransactions = [];
+    for (const transaction of transactions) {
+      const signed = await this.signTransaction(transaction);
+      signedTransactions.push(signed);
+    }
+    return signedTransactions;
   }
   /**
-   * Transfer SPL token (requires PIN)
-   *
-   * @param params - Transfer parameters
-   * @returns Transaction signature and serialized transaction
+   * Unified transfer: SOL, SPL token, or NFT
+   * - No mintAddress → native SOL transfer (kind='native')
+   * - With mintAddress → SPL/NFT transfer (kind='spl')
+   * - NFT = transfer({ mintAddress, toAddress, amount: 1 })
    */
-  async transferSPL(params) {
+  async transfer(params) {
     if (!this.wallet) {
       throw new SolanaProviderError(
         SolanaErrorCode.DISCONNECTED,
         "Wallet not connected"
       );
     }
-    if (!this.requestPinCallback) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.UNAUTHORIZED,
-        "PIN callback not set"
-      );
-    }
     try {
-      const pin = await this.requestPinCallback();
-      const encoder = new TextEncoder();
-      const data = encoder.encode(pin);
-      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      const pinHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-      const storedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
-      if (storedPinHash && pinHash !== storedPinHash) {
+      const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (!pinHash) {
         throw new SolanaProviderError(
-          SolanaErrorCode.UNAUTHORIZED,
-          "Incorrect PIN"
+          SolanaErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
         );
       }
-      const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
-      const { PublicKey, Connection } = await import("@solana/web3.js");
-      const connection = new Connection(this.getRpcUrl(), "confirmed");
-      const mintPubkey = new PublicKey(params.mintAddress);
-      const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
-      const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
-      const rawAmount = Math.floor(params.amount * 10 ** decimals);
-      const txGenResponse = await this.client.solana.generateSPLTransferTransaction({
-        network: apiNetwork,
-        mintAddress: params.mintAddress,
-        fromAddress: this.wallet.address,
+      console.log(`[AbcSolanaProvider] transfer START`, {
+        kind: params.mintAddress ? "spl" : "native",
         toAddress: params.toAddress,
-        amount: rawAmount,
-        decimals,
-        // Optional - enables transferChecked instruction
-        feePayerAddress: this.wallet.address
+        amount: params.amount,
+        mintAddress: params.mintAddress || null,
+        network: this.wallet.network,
+        hasPinHash: !!pinHash
       });
-      const signatureResponse = await this.client.solana.signSolanaTransaction({
-        keyId: this.wallet.keyId,
-        encryptedShare: this.wallet.encryptedShare,
-        secretStore: this.wallet.secretStore || "",
-        message: txGenResponse.serialized_tx
+      const api = this.talkenApi || getTalkenApiClient();
+      if (params.mintAddress) {
+        const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
+        const { PublicKey, Connection } = await import("@solana/web3.js");
+        const connection = new Connection(this.getRpcUrl(), "confirmed");
+        const mintPubkey = new PublicKey(params.mintAddress);
+        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
+        const rawAmount = Math.floor(params.amount * 10 ** decimals);
+        const result2 = await api.solana.transfer({
+          kind: "spl",
+          toAddress: params.toAddress,
+          mintAddress: params.mintAddress,
+          amount: String(rawAmount),
+          decimals,
+          network: apiNetwork,
+          pin: pinHash
+        });
+        console.log(`[AbcSolanaProvider] SPL transfer result:`, result2);
+        return { signature: result2.txHash || result2.txSignature };
+      }
+      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+      const amountLamports = params.amount * LAMPORTS_PER_SOL;
+      console.log(`[AbcSolanaProvider] native transfer request:`, {
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        amountSOL: params.amount
       });
-      const result = await this.client.solana.sendSolanaTransaction({
-        network: apiNetwork,
-        serializedTX: txGenResponse.serialized_tx,
-        signatures: [signatureResponse.signature]
+      const result = await api.solana.transfer({
+        kind: "native",
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        pin: pinHash
       });
-      return {
-        signature: result.txHash,
-        serializedTx: txGenResponse.serialized_tx
-      };
+      console.log(`[AbcSolanaProvider] native transfer result:`, result);
+      return { signature: result.txHash || result.txSignature };
     } catch (error) {
-      console.error("[AbcSolanaProvider] \u274C SPL transfer failed:", error);
+      console.error(`[AbcSolanaProvider] transfer FAILED:`, {
+        message: error.message,
+        code: error.code,
+        status: error.status,
+        details: error.details || error.data
+      });
       if (error.code === 4001 || error.cancelled) {
         throw error;
       }
       this.emit("error", error);
       throw new SolanaProviderError(
         SolanaErrorCode.INTERNAL_ERROR,
-        "Failed to transfer SPL token",
+        "Failed to transfer",
         error
       );
     }
   }
   /**
-   * Transfer NFT (Solana NFT = SPL token with decimals: 0, amount: 1)
-   *
-   * @param params - Transfer parameters
-   * @returns Transaction signature and serialized transaction
+   * Get wallet info
    */
-  async transferNFT(params) {
-    return this.transferSPL({
-      mintAddress: params.mintAddress,
-      toAddress: params.toAddress,
-      amount: 1,
-      // NFTs always transfer 1 unit
-      createAccountIfNeeded: params.createAccountIfNeeded
-    });
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      network: this.wallet.network
+    };
   }
   /**
    * Get SPL token balance

package/dist/wallets/walletConnectors/{chunk-2KHZAE46.js → chunk-MRFTCMBN.js}

@@ -1,19 +1,24 @@
 "use client";
+import {
+  createTalkenApiClient
+} from "./chunk-BBD77PEX.js";
 import {
   abcConnector
-} from "./chunk-2NHQTZGS.js";
+} from "./chunk-OTES5NGR.js";
 import {
   ABC_WALLET_METADATA
-} from "./chunk-VETRBBA2.js";
+} from "./chunk-DHHVIM22.js";
 
 // src/wallets/walletConnectors/abcWallet/abcWallet.ts
+import { setTalkenApiClient } from "@talken/talkenkit";
 var abcWallet = (specificOptions) => ({ projectId }) => {
-  const waasUrl = specificOptions?.waasUrl || process.env.NEXT_PUBLIC_ABC_WAAS_URL || process.env.VITE_ABC_WAAS_URL;
-  if (!waasUrl) {
-    throw new Error(
-      'ABC WaaS URL is required. Please provide it via:\n1. abcWallet({ waasUrl: "..." }) options, or\n2. NEXT_PUBLIC_ABC_WAAS_URL environment variable, or\n3. VITE_ABC_WAAS_URL environment variable'
-    );
-  }
+  const talkenApiUrl = specificOptions?.talkenApiUrl || process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001/api/v1";
+  const talkenApi = createTalkenApiClient({
+    baseUrl: talkenApiUrl,
+    debug: specificOptions?.environment === "development"
+  });
+  setTalkenApiClient(talkenApi);
+  const waasUrl = specificOptions?.waasUrl || process.env.NEXT_PUBLIC_ABC_WAAS_URL || process.env.VITE_ABC_WAAS_URL || "";
   const config = {
     waasUrl,
     apiKey: specificOptions?.apiKey,

package/dist/wallets/walletConnectors/chunk-NBEDPUHX.js

@@ -0,0 +1,91 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-7ZCM4DCC.js";
+import {
+  createAbcError
+} from "./chunk-6LH6ZME2.js";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-DHHVIM22.js";
+
+// src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
+var TransactionApi = class extends BaseApiClient {
+  /**
+   * 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;
+  }
+};
+
+export {
+  TransactionApi
+};