@talken/talkenkit 2.4.16 → 2.4.18

package/dist/wallets/walletConnectors/{chunk-UX4IUIRD.js → chunk-F5C6OZYF.js}

@@ -1,10 +1,16 @@
 "use client";
+import {
+  getChainKey,
+  getNetworkName
+} from "./chunk-7QHCSJDN.js";
 import {
   hexToNumber,
   numberToHex
-} from "./chunk-5RSS3SRV.js";
+} from "./chunk-6LH6ZME2.js";
 
 // src/wallets/walletConnectors/abcWallet/abcProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+import { parseGwei } from "viem";
 var EventEmitter = class {
   constructor() {
     this.events = /* @__PURE__ */ new Map();
@@ -104,22 +110,35 @@ var AbcEvmProvider = class extends EventEmitter {
     this.emit("accountsChanged", []);
   }
   /**
-   * Set PIN request callback
+   * Set request interceptor for sign confirmation
+   * The interceptor is called before signing operations to show confirmation UI
    */
-  setRequestPinCallback(callback) {
-    this.requestPinCallback = callback;
+  setRequestInterceptor(interceptor) {
+    this.requestInterceptor = interceptor;
   }
   /**
-   * Request PIN from user
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, transaction methods will use a single API call instead of multi-step WaaS
    */
-  async requestPin() {
-    if (!this.requestPinCallback) {
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        "PIN request callback not configured"
-      );
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  /**
+   * Call request interceptor if configured
+   * Called by specific signing/transaction methods that need user confirmation
+   * @returns Resolved transaction with user modifications if changed in confirmation modal
+   */
+  async callInterceptor(method, params) {
+    if (!this.requestInterceptor) {
+      return void 0;
     }
-    return this.requestPinCallback();
+    const request = {
+      method,
+      params,
+      chainId: this.chainId,
+      address: this.wallet?.address || ""
+    };
+    return this.requestInterceptor(request);
   }
   /**
    * EIP-1193 request method
@@ -220,7 +239,37 @@ var AbcEvmProvider = class extends EventEmitter {
         "Invalid transaction params"
       );
     }
+    const resolved = await this.callInterceptor("eth_sendTransaction", params);
     const tx = params[0];
+    if (resolved) {
+      if (resolved.data) {
+        tx.data = resolved.data;
+      }
+      if (resolved.gasFee?.maxFeePerGas) {
+        try {
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
+          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
+            error
+          );
+        }
+      }
+      if (resolved.gasFee?.maxPriorityFeePerGas) {
+        try {
+          const priorityFeeWei = parseGwei(
+            resolved.gasFee.maxPriorityFeePerGas
+          );
+          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
+            error
+          );
+        }
+      }
+    }
     const isContractDeployment = !tx.to || tx.to === "0x" || tx.to === "0x0" || tx.to === "0x0000000000000000000000000000000000000000";
     if (isContractDeployment) {
       tx.to = "0x";
@@ -230,27 +279,27 @@ var AbcEvmProvider = class extends EventEmitter {
         'Transaction must have "to" field'
       );
     }
-    const pin = await this.requestPin();
-    const signParams = {
-      chainId: this.chainId,
-      transaction: tx,
-      keyId: this.wallet.keyId,
-      encryptedShare: this.wallet.encryptedShare,
-      pin
-    };
-    const signResult = await this.client.signTransaction(signParams);
-    if (!signResult.signature) {
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+    if (!pinHash) {
       throw new ProviderRpcError(
         ErrorCode.INTERNAL_ERROR,
-        "Failed to get signed transaction from ABC WaaS"
+        "PIN hash not found. Please login again."
       );
     }
-    const sendResult = await this.client.sendRawTransaction(
-      this.chainId,
-      signResult.signature
-      // serializedTx
-    );
-    return sendResult.txHash;
+    const hexValue = tx.value || "0x0";
+    const amountWei = BigInt(hexValue).toString();
+    const api = this.talkenApi || getTalkenApiClient();
+    const result = await api.evm.sendTransaction({
+      chainKey: getChainKey(this.chainId),
+      to: tx.to,
+      amountWei,
+      pin: pinHash,
+      data: tx.data || "0x",
+      gasLimit: tx.gas || tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+    });
+    return result.txHash;
   }
   /**
    * Sign transaction (without sending)
@@ -268,16 +317,48 @@ var AbcEvmProvider = class extends EventEmitter {
         "Invalid transaction params"
       );
     }
+    const resolved = await this.callInterceptor("eth_signTransaction", params);
     const tx = params[0];
-    const pin = await this.requestPin();
-    const signParams = {
-      chainId: this.chainId,
-      transaction: tx,
-      keyId: this.wallet.keyId,
-      encryptedShare: this.wallet.encryptedShare,
-      pin
-    };
-    const result = await this.client.signTransaction(signParams);
+    if (resolved) {
+      if (resolved.data) {
+        tx.data = resolved.data;
+      }
+      if (resolved.gasFee?.maxFeePerGas) {
+        try {
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
+          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
+            error
+          );
+        }
+      }
+      if (resolved.gasFee?.maxPriorityFeePerGas) {
+        try {
+          const priorityFeeWei = parseGwei(
+            resolved.gasFee.maxPriorityFeePerGas
+          );
+          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
+            error
+          );
+        }
+      }
+    }
+    const api = this.talkenApi || getTalkenApiClient();
+    const result = await api.evm.signTransaction({
+      network: getNetworkName(this.chainId),
+      to: tx.to,
+      value: tx.value || "0x0",
+      data: tx.data || "0x",
+      gasLimit: tx.gas || tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      nonce: tx.nonce ? String(Number.parseInt(tx.nonce, 16)) : void 0
+    });
     return result.signature;
   }
   /**
@@ -298,6 +379,7 @@ var AbcEvmProvider = class extends EventEmitter {
         "Invalid personal_sign params"
       );
     }
+    await this.callInterceptor("personal_sign", params);
     const [message, address] = params;
     if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
       console.error("[AbcProvider] \u274C Address mismatch");
@@ -306,35 +388,14 @@ var AbcEvmProvider = class extends EventEmitter {
         "Address does not match connected wallet"
       );
     }
-    if (!this.wallet.sid) {
-      console.error("[AbcProvider] \u274C Missing sid");
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        "Wallet session ID (sid) is missing - please reconnect wallet"
-      );
-    }
-    if (!this.wallet.pvencstr) {
-      console.error("[AbcProvider] \u274C Missing pvencstr");
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        "Wallet pvencstr is missing - please reconnect wallet"
-      );
-    }
-    if (!this.wallet.wid) {
-      console.error("[AbcProvider] \u274C Missing wid");
-      throw new ProviderRpcError(
-        ErrorCode.INTERNAL_ERROR,
-        "Wallet wid is missing - please reconnect wallet"
-      );
-    }
-    const result = await this.client.signMessage({
+    const api = this.talkenApi || getTalkenApiClient();
+    const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
+    const result = await api.evm.signPersonal({
+      network,
       message,
-      address: this.wallet.address,
-      // ciphertext removed - not needed for message signing
-      sid: this.wallet.sid,
-      uid: this.wallet.uid,
-      pvencstr: this.wallet.pvencstr,
-      wid: this.wallet.wid
+      address,
+      pin: pinHash
     });
     return result.signature;
   }
@@ -367,6 +428,7 @@ var AbcEvmProvider = class extends EventEmitter {
         "Invalid signTypedData params"
       );
     }
+    await this.callInterceptor("eth_signTypedData_v4", params);
     const [address, typedData] = params;
     if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
       throw new ProviderRpcError(
@@ -374,9 +436,13 @@ var AbcEvmProvider = class extends EventEmitter {
         "Address does not match connected wallet"
       );
     }
-    const result = await this.client.signTypedData({
-      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData)
-      // ciphertext removed - not needed for typed data signing
+    const api = this.talkenApi || getTalkenApiClient();
+    const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
+    const result = await api.evm.signTypedData({
+      network,
+      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
+      pin: pinHash
     });
     return result.signature;
   }
@@ -413,7 +479,6 @@ var AbcEvmProvider = class extends EventEmitter {
    * Get transaction count (nonce) using ABC WaaS API
    */
   async eth_getTransactionCount(params) {
-    console.log("[AbcEvmProvider] \u{1F4CA} Getting transaction count for ABC Wallet");
     const address = params[0]?.toLowerCase();
     if (!address) {
       throw new ProviderRpcError(
@@ -422,18 +487,11 @@ var AbcEvmProvider = class extends EventEmitter {
       );
     }
     const currentChainId = this.chainId;
-    console.log("[AbcEvmProvider] Transaction count for:", {
-      address,
-      chainId: currentChainId
-    });
     try {
       const nonce = await this.client.getTransactionCount({
         chainId: currentChainId,
         address
       });
-      console.log(
-        `[AbcEvmProvider] \u2705 Transaction count from ABC WaaS: ${nonce}`
-      );
       return nonce;
     } catch (error) {
       console.error(
@@ -503,8 +561,12 @@ var AbcEvmProvider = class extends EventEmitter {
     return this.chainId;
   }
 };
-function createAbcEvmProvider(client) {
-  return new AbcEvmProvider(client);
+function createAbcEvmProvider(client, talkenApi) {
+  const provider = new AbcEvmProvider(client);
+  if (talkenApi) {
+    provider.setTalkenApi(talkenApi);
+  }
+  return provider;
 }
 var createAbcProvider = createAbcEvmProvider;
 

package/dist/wallets/walletConnectors/{chunk-3AV4L2Z3.js → chunk-GRN6YAJC.js}

@@ -1,22 +1,28 @@
 "use client";
 import {
-  AuthApi
-} from "./chunk-ZNBWRE3K.js";
+  TransactionApi
+} from "./chunk-NBEDPUHX.js";
 import {
-  BitcoinApi
-} from "./chunk-V4Q3GNBX.js";
+  WalletApi
+} from "./chunk-QHCLOJYA.js";
 import {
-  SigningApi
-} from "./chunk-7VZDITAJ.js";
+  WalletscanApi
+} from "./chunk-7MDXHYMB.js";
 import {
-  TransactionApi
-} from "./chunk-DJKN2MCI.js";
+  TronApi
+} from "./chunk-RS36ZX4P.js";
 import {
-  WalletApi
-} from "./chunk-V33I7JGZ.js";
+  AuthApi
+} from "./chunk-O47OQDRJ.js";
+import {
+  BitcoinApi
+} from "./chunk-CPAYLZZL.js";
+import {
+  GasApi
+} from "./chunk-IX6DQDRE.js";
 import {
   SolanaApi
-} from "./chunk-HQQESMZJ.js";
+} from "./chunk-C4L5XI6N.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {
@@ -24,9 +30,11 @@ var AbcWaasApiClient = class {
     this.auth = new AuthApi(config);
     this.wallet = new WalletApi(config);
     this.transaction = new TransactionApi(config);
-    this.signing = new SigningApi(config);
     this.solana = new SolanaApi(config);
     this.bitcoin = new BitcoinApi(config);
+    this.tron = new TronApi(config);
+    this.walletscan = new WalletscanApi(config);
+    this.gas = new GasApi(config);
   }
   /**
    * Check if user is authenticated

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

@@ -0,0 +1,289 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcTronProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var TronErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  INSUFFICIENT_FUNDS: 5001
+};
+var TronProviderError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "TronProviderError";
+  }
+};
+var TRON_NETWORKS = {
+  mainnet: {
+    name: "TRON Mainnet",
+    type: "tron",
+    explorer: "https://tronscan.org"
+  },
+  nile: {
+    name: "TRON Nile Testnet",
+    type: "tron_nile",
+    explorer: "https://nile.tronscan.org"
+  }
+};
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+      return true;
+    }
+    return false;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+};
+var AbcTronProvider = class extends EventEmitter {
+  constructor(_client) {
+    super();
+    this.wallet = null;
+    this.network = TRON_NETWORKS.mainnet;
+    this.connected = false;
+  }
+  /**
+   * Set wallet information
+   */
+  setWallet(wallet) {
+    const previousAddress = this.wallet?.address;
+    this.wallet = wallet;
+    this.connected = true;
+    if (wallet.network === "tron") {
+      this.network = TRON_NETWORKS.mainnet;
+    } else {
+      this.network = TRON_NETWORKS.nile;
+    }
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+    }
+    this.emit("connect", {
+      address: wallet.address,
+      network: this.network.type
+    });
+    console.log(
+      "[TronProvider] \u2705 Wallet connected:",
+      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 6)}`
+    );
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.emit("disconnect");
+    this.emit("accountsChanged", []);
+    console.log("[TronProvider] \u{1F50C} Wallet disconnected");
+  }
+  /**
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, sendTransaction will use a single API call instead of multi-step WaaS
+   */
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.wallet !== null;
+  }
+  /**
+   * Get TRON address
+   */
+  async getAddress() {
+    if (!this.wallet) {
+      throw new TronProviderError(
+        TronErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.address;
+  }
+  /**
+   * Get public key
+   */
+  async getPublicKey() {
+    if (!this.wallet) {
+      throw new TronProviderError(
+        TronErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.publicKey;
+  }
+  /**
+   * Get current network
+   */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+   * Sign TRON message (not supported)
+   */
+  async signMessage(_message) {
+    throw new TronProviderError(
+      TronErrorCode.UNSUPPORTED_METHOD,
+      "TRON message signing is not supported. Use sendTransaction() instead."
+    );
+  }
+  /**
+   * Send TRON transaction (TRX native or TRC20)
+   * Complete flow: create unsigned tx -> request PIN -> sign -> broadcast
+   *
+   * @param params - Transaction parameters
+   * @returns Transaction hash
+   */
+  async sendTransaction(params) {
+    if (!this.wallet) {
+      throw new TronProviderError(
+        TronErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      console.log("[TronProvider] \u{1F4B8} Starting TRON transaction...");
+      const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (!pinHash) {
+        throw new TronProviderError(
+          TronErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
+        );
+      }
+      const txType = params.contractAddress ? "TRC20" : "NATIVE";
+      let amountRaw;
+      if (txType === "NATIVE") {
+        amountRaw = Math.floor(
+          Number.parseFloat(params.amount) * 1e6
+        ).toString();
+        console.log(
+          `[TronProvider] Converting ${params.amount} TRX -> ${amountRaw} SUN`
+        );
+      } else {
+        const decimals = params.decimals ?? 6;
+        amountRaw = Math.floor(
+          Number.parseFloat(params.amount) * 10 ** decimals
+        ).toString();
+        console.log(
+          `[TronProvider] Converting ${params.amount} -> ${amountRaw} (decimals: ${decimals})`
+        );
+      }
+      let email;
+      try {
+        const authState = localStorage.getItem("talkenkit_abc_auth_state");
+        if (authState) {
+          const authData = JSON.parse(authState);
+          email = authData.user?.email;
+        }
+      } catch {
+      }
+      const api = this.talkenApi || getTalkenApiClient();
+      const request = txType === "NATIVE" ? {
+        kind: "native",
+        network: this.network.type,
+        toAddress: params.toAddress,
+        amountSun: amountRaw,
+        pin: pinHash,
+        ...email && { email }
+      } : {
+        kind: "trc20",
+        network: this.network.type,
+        toAddress: params.toAddress,
+        contractAddress: params.contractAddress,
+        amount: amountRaw,
+        feeLimit: params.feeLimit,
+        pin: pinHash,
+        ...email && { email }
+      };
+      const result = await api.tron.transferTrx(request);
+      const txHash = result.txHash;
+      console.log(
+        `[TronProvider] \u2705 ${txType === "NATIVE" ? "TRX" : "TRC-20"} transaction complete via TalkenApiClient:`,
+        txHash
+      );
+      this.emit("transactionBroadcasted", {
+        txHash,
+        explorerUrl: `${this.network.explorer}/#/transaction/${txHash}`
+      });
+      return txHash;
+    } catch (error) {
+      if (error.message?.includes("cancelled") || error.message?.includes("rejected")) {
+        console.log("[TronProvider] \u2139\uFE0F User cancelled transaction");
+        throw new TronProviderError(
+          TronErrorCode.USER_REJECTED,
+          "User rejected transaction",
+          error
+        );
+      }
+      console.error("[TronProvider] \u274C Transaction failed:", error.message);
+      if (error.message?.includes("insufficient")) {
+        throw new TronProviderError(
+          TronErrorCode.INSUFFICIENT_FUNDS,
+          "Insufficient TRX balance",
+          error
+        );
+      }
+      this.emit("error", error);
+      throw new TronProviderError(
+        TronErrorCode.INTERNAL_ERROR,
+        error.message || "Failed to send TRON transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      network: this.network.type
+    };
+  }
+};
+
+export {
+  TronProviderError,
+  TRON_NETWORKS,
+  AbcTronProvider
+};