@talken/talkenkit 2.4.23 → 2.4.24

package/dist/wallets/walletConnectors/chunk-6YUJPIJ5.js

@@ -0,0 +1,351 @@
+"use client";
+import {
+  getCredentialManager
+} from "./chunk-QHUBLT7N.js";
+
+// src/wallets/walletConnectors/abcWallet/abcTronProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+function isTalkenApiClient(client) {
+  return typeof client?.tron?.transferTrx === "function";
+}
+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;
+    this.tokenMetadataCache = /* @__PURE__ */ new Map();
+    if (isTalkenApiClient(client)) {
+      this.talkenApi = client;
+    }
+  }
+  /**
+   * Set request interceptor for transfer confirmation modals
+   */
+  setRequestInterceptor(interceptor) {
+    this.requestInterceptor = interceptor;
+  }
+  /**
+   * Call request interceptor if set (throws on user cancel)
+   */
+  async callInterceptor(request) {
+    if (this.requestInterceptor) {
+      await this.requestInterceptor(request);
+    }
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Fetch token metadata (symbol, logo) from walletscan API with caching.
+   * Falls back to 'TRX'/'TRC20' on failure.
+   */
+  async fetchTokenMetadata(contractAddress) {
+    const cacheKey = contractAddress || "__native__";
+    const cached = this.tokenMetadataCache.get(cacheKey);
+    if (cached)
+      return cached;
+    try {
+      const api = this.talkenApi || getTalkenApiClient();
+      const chainKeys = this.network.type === "tron_nile" ? "tronNile" : "tron";
+      let tokens;
+      if (contractAddress) {
+        tokens = await api.walletscan.getToken({ chainKeys, contractAddress });
+      } else {
+        tokens = await api.walletscan.getNativeTokens({
+          chainKeys,
+          walletAddress: this.wallet.address
+        });
+      }
+      if (tokens.length > 0) {
+        const info = { symbol: tokens[0].symbol, logo: tokens[0].logo };
+        this.tokenMetadataCache.set(cacheKey, info);
+        return info;
+      }
+    } catch {
+    }
+    return { symbol: contractAddress ? "TRC20" : "TRX" };
+  }
+  /**
+   * 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 {
+      const tokenMetadata = await this.fetchTokenMetadata(
+        params.contractAddress
+      );
+      await this.callInterceptor({
+        chain: "tron",
+        method: "sendTransaction",
+        fromAddress: this.wallet.address,
+        toAddress: params.toAddress,
+        amount: params.amount,
+        symbol: tokenMetadata.symbol,
+        network: this.network.type,
+        tokenAddress: params.contractAddress,
+        isNativeToken: !params.contractAddress,
+        feeSymbol: "TRX",
+        tokenLogo: tokenMetadata.logo
+      });
+      console.log("[TronProvider] \u{1F4B8} Starting TRON transaction...");
+      const pinHash = getCredentialManager().getPinHash();
+      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})`
+        );
+      }
+      const email = getCredentialManager().getEmail() || void 0;
+      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
+};

package/dist/wallets/walletConnectors/chunk-77YYMCMD.js

@@ -0,0 +1,273 @@
+"use client";
+import {
+  loadAuthState,
+  saveAuthState
+} from "./chunk-7EQNUYV2.js";
+
+// src/wallets/walletConnectors/abcWallet/abcBitcoinConnector.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AbcBitcoinConnector = class {
+  constructor(config) {
+    this.wallet = null;
+    this.connected = false;
+    // Event listeners
+    this.connectListeners = /* @__PURE__ */ new Set();
+    this.disconnectListeners = /* @__PURE__ */ new Set();
+    this.accountsChangedListeners = /* @__PURE__ */ new Set();
+    this.networkChangedListeners = /* @__PURE__ */ new Set();
+    this.provider = config.provider;
+    this.setupProviderListeners();
+  }
+  /**
+   * Setup provider event listeners
+   */
+  setupProviderListeners() {
+    this.provider.on("connect", () => {
+      this.connected = true;
+      if (this.wallet) {
+        for (const listener of this.connectListeners) {
+          listener(this.wallet);
+        }
+      }
+    });
+    this.provider.on("disconnect", () => {
+      this.connected = false;
+      this.wallet = null;
+      for (const listener of this.disconnectListeners) {
+        listener();
+      }
+    });
+    this.provider.on("accountsChanged", (accounts) => {
+      for (const listener of this.accountsChangedListeners) {
+        listener(accounts);
+      }
+    });
+    this.provider.on("networkChanged", (network) => {
+      for (const listener of this.networkChangedListeners) {
+        listener(network);
+      }
+    });
+  }
+  /**
+   * Connect Bitcoin wallet
+   */
+  async connect() {
+    try {
+      const authState = loadAuthState();
+      console.log("[BitcoinConnector] \u{1F527} connect() called:", {
+        hasAuthState: !!authState,
+        isAuthenticated: authState?.isAuthenticated,
+        hasBitcoinWallet: !!authState?.bitcoinWallet,
+        bitcoinAddress: authState?.bitcoinWallet?.address
+      });
+      if (!authState || !authState.isAuthenticated || !authState.bitcoinWallet) {
+        throw new Error("BITCOIN_LOGIN_REQUIRED");
+      }
+      this.wallet = authState.bitcoinWallet;
+      this.provider.setWallet(authState.bitcoinWallet);
+      console.log("[BitcoinConnector] \u2705 Wallet set:", {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        addressType: authState.bitcoinWallet.addressType,
+        network: authState.bitcoinWallet.network
+      });
+      this.connected = true;
+      return {
+        address: authState.bitcoinWallet.address,
+        publicKey: authState.bitcoinWallet.publicKey,
+        network: authState.bitcoinWallet.network
+      };
+    } catch (error) {
+      if (error.message === "BITCOIN_LOGIN_REQUIRED") {
+        throw error;
+      }
+      console.error("[BitcoinConnector] \u274C connect error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect Bitcoin wallet
+   */
+  async disconnect() {
+    try {
+      this.provider.clearWallet();
+      this.wallet = null;
+      this.connected = false;
+      console.log("[BitcoinConnector] \u2705 Wallet disconnected");
+    } catch (error) {
+      console.error("[BitcoinConnector] \u274C disconnect error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get Bitcoin address
+   */
+  async getAddress() {
+    return this.provider.getAddress();
+  }
+  /**
+   * Get compressed public key (33 bytes)
+   */
+  async getPublicKey() {
+    return this.provider.getPublicKey();
+  }
+  /**
+   * Get address type (bech32, p2pkh, etc.)
+   */
+  getAddressType() {
+    return this.provider.getAddressType();
+  }
+  /**
+   * Get UTXOs
+   */
+  async getUtxos(forceRefresh = false) {
+    return this.provider.getUtxos(forceRefresh);
+  }
+  /**
+   * Get balance (in satoshis)
+   */
+  async getBalance(forceRefresh = false) {
+    return this.provider.getBalance(forceRefresh);
+  }
+  /**
+   * Estimate transaction fee
+   */
+  async estimateFee(targetBlocks = 6) {
+    return this.provider.estimateFee(targetBlocks);
+  }
+  /**
+   * Sign Bitcoin message (BIP-322)
+   * NOTE: Currently not supported - Bitcoin uses v2 API which doesn't have message signing endpoint
+   */
+  async signMessage(message) {
+    return this.provider.signMessage(message);
+  }
+  /**
+   * Send Bitcoin transaction (high-level API)
+   * Creates, signs, and broadcasts transaction
+   */
+  async sendTransaction(params) {
+    return this.provider.sendTransaction(params);
+  }
+  /**
+   * Broadcast signed transaction to network (low-level API)
+   */
+  async broadcastTransaction(rawTransaction, psbt) {
+    return this.provider.broadcastTransaction(rawTransaction, psbt);
+  }
+  /**
+   * Check if authorized (has valid session)
+   */
+  async isAuthorized() {
+    try {
+      const authState = loadAuthState();
+      if (!authState || !authState.isAuthenticated) {
+        return false;
+      }
+      if (!authState.bitcoinWallet) {
+        return false;
+      }
+      const api = getTalkenApiClient();
+      return !!api && !api.isTokenExpired();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.provider.isConnected();
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get provider
+   */
+  getProvider() {
+    return this.provider;
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    return this.provider.getWalletInfo();
+  }
+  /**
+   * Switch network
+   */
+  async switchNetwork(network) {
+    this.provider.setNetwork(network);
+    const authState = loadAuthState();
+    if (authState?.bitcoinWallet) {
+      authState.bitcoinWallet.network = network === "mainnet" ? "bitcoin" /* Mainnet */ : "bitcoin_testnet" /* Testnet */;
+      saveAuthState(authState);
+    }
+    console.log("[BitcoinConnector] \u{1F504} Network switched to:", network);
+  }
+  /**
+   * Get current network
+   */
+  getNetwork() {
+    return this.provider.getNetwork().type;
+  }
+  /**
+   * Refresh UTXO cache
+   */
+  async refreshUtxos() {
+    return this.provider.refreshUtxos();
+  }
+  on(event, listener) {
+    switch (event) {
+      case "connect":
+        this.connectListeners.add(listener);
+        break;
+      case "disconnect":
+        this.disconnectListeners.add(listener);
+        break;
+      case "accountsChanged":
+        this.accountsChangedListeners.add(listener);
+        break;
+      case "networkChanged":
+        this.networkChangedListeners.add(listener);
+        break;
+    }
+  }
+  off(event, listener) {
+    switch (event) {
+      case "connect":
+        this.connectListeners.delete(listener);
+        break;
+      case "disconnect":
+        this.disconnectListeners.delete(listener);
+        break;
+      case "accountsChanged":
+        this.accountsChangedListeners.delete(listener);
+        break;
+      case "networkChanged":
+        this.networkChangedListeners.delete(listener);
+        break;
+    }
+  }
+  /**
+   * Remove all listeners
+   */
+  removeAllListeners() {
+    this.connectListeners.clear();
+    this.disconnectListeners.clear();
+    this.accountsChangedListeners.clear();
+    this.networkChangedListeners.clear();
+  }
+};
+function createAbcBitcoinConnector(config) {
+  return new AbcBitcoinConnector(config);
+}
+
+export {
+  AbcBitcoinConnector,
+  createAbcBitcoinConnector
+};