@talken/talkenkit 2.4.16 → 2.4.17

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

@@ -0,0 +1,46 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/types.ts
+var AbcStorageKey = /* @__PURE__ */ ((AbcStorageKey2) => {
+  AbcStorageKey2["USER"] = "user";
+  AbcStorageKey2["WALLET"] = "wallet";
+  AbcStorageKey2["SOLANA_WALLET"] = "solana_wallet";
+  AbcStorageKey2["BITCOIN_WALLET"] = "bitcoin_wallet";
+  AbcStorageKey2["TRON_WALLET"] = "tron_wallet";
+  AbcStorageKey2["ACCESS_TOKEN"] = "access_token";
+  AbcStorageKey2["REFRESH_TOKEN"] = "refresh_token";
+  AbcStorageKey2["EXPIRES_AT"] = "expires_at";
+  AbcStorageKey2["PIN"] = "pin";
+  AbcStorageKey2["AUTH_STATE"] = "auth_state";
+  AbcStorageKey2["ENCRYPTED_TOKENS"] = "encrypted_tokens";
+  AbcStorageKey2["TOKEN_SALT"] = "token_salt";
+  return AbcStorageKey2;
+})(AbcStorageKey || {});
+var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode2) => {
+  AbcErrorCode2["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+  AbcErrorCode2["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+  AbcErrorCode2["WALLET_NOT_FOUND"] = "WALLET_NOT_FOUND";
+  AbcErrorCode2["INVALID_PIN"] = "INVALID_PIN";
+  AbcErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  AbcErrorCode2["SIGNATURE_FAILED"] = "SIGNATURE_FAILED";
+  AbcErrorCode2["USER_CANCELLED"] = "USER_CANCELLED";
+  AbcErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  AbcErrorCode2["ENCRYPTION_FAILED"] = "ENCRYPTION_FAILED";
+  AbcErrorCode2["DECRYPTION_FAILED"] = "DECRYPTION_FAILED";
+  return AbcErrorCode2;
+})(AbcErrorCode || {});
+var AbcError = class extends Error {
+  constructor(code, message, details, statusCode) {
+    super(message);
+    this.name = "AbcError";
+    this.code = code;
+    this.details = details;
+    this.statusCode = statusCode;
+  }
+};
+
+export {
+  AbcStorageKey,
+  AbcErrorCode,
+  AbcError
+};

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

@@ -0,0 +1,66 @@
+"use client";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+import {
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/klipWallet/klipWallet.ts
+var klipWallet = ({
+  projectId,
+  walletConnectParameters
+}) => {
+  const isKlipWalletInjected = hasInjectedProvider({
+    namespace: "klip"
+  });
+  const shouldUseWalletConnect = true;
+  const getUri = (uri) => {
+    return `klip://walletconnect?uri=${encodeURIComponent(uri)}`;
+  };
+  return {
+    id: "klip",
+    name: "Klip Wallet",
+    iconUrl: async () => (await import("./klipWallet-PPTYYB5G.js")).default,
+    installed: isKlipWalletInjected || void 0,
+    iconBackground: "#FEE500",
+    downloadUrls: {
+      ios: "https://apps.apple.com/kr/app/klip/id1627665524",
+      android: "https://play.google.com/store/apps/details?id=com.klipwallet.app",
+      mobile: "https://klipwallet.com",
+      qrCode: "https://klipwallet.com"
+    },
+    mobile: { getUri: shouldUseWalletConnect ? getUri : void 0 },
+    qrCode: shouldUseWalletConnect ? {
+      getUri: (uri) => uri,
+      instructions: {
+        learnMoreUrl: "https://klipwallet.com",
+        steps: [
+          {
+            description: "wallet_connectors.klip.qr_code.step1.description",
+            step: "install",
+            title: "wallet_connectors.klip.qr_code.step1.title"
+          },
+          {
+            description: "wallet_connectors.klip.qr_code.step2.description",
+            step: "create",
+            title: "wallet_connectors.klip.qr_code.step2.title"
+          },
+          {
+            description: "wallet_connectors.klip.qr_code.step3.description",
+            step: "refresh",
+            title: "wallet_connectors.klip.qr_code.step3.title"
+          }
+        ]
+      }
+    } : void 0,
+    createConnector: getWalletConnectConnector({
+      projectId,
+      walletConnectParameters
+    })
+  };
+};
+
+export {
+  klipWallet
+};

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

@@ -0,0 +1,182 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-25V3FW3O.js";
+import {
+  getNetworkName
+} from "./chunk-7QHCSJDN.js";
+import {
+  createAbcError
+} from "./chunk-GO6OLTNF.js";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-YJH4BHSB.js";
+
+// src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
+var TransactionApi = class extends BaseApiClient {
+  /**
+   * Send raw transaction
+   */
+  async sendRawTransaction(chainId, signedTransaction) {
+    const network = 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;
+  }
+};
+
+export {
+  TransactionApi
+};

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

@@ -0,0 +1,317 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcTronProvider.ts
+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.client = client;
+  }
+  /**
+   * 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 PIN request callback for transaction signing
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user
+   */
+  async requestPin() {
+    const globalRequestPin = window.__TALKENKIT_REQUEST_PIN__;
+    if (globalRequestPin && typeof globalRequestPin === "function") {
+      return globalRequestPin("transaction");
+    }
+    if (!this.requestPinCallback) {
+      throw new TronProviderError(
+        TronErrorCode.INTERNAL_ERROR,
+        "PIN request callback not configured. Make sure RainbowKitProvider is rendered."
+      );
+    }
+    return this.requestPinCallback();
+  }
+  /**
+   * 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 authStateKey = "talkenkit_abc_auth_state";
+      const authState = typeof window !== "undefined" ? localStorage.getItem(authStateKey) : null;
+      if (!authState) {
+        throw new TronProviderError(
+          TronErrorCode.UNAUTHORIZED,
+          "Not authenticated - auth state not found"
+        );
+      }
+      const parsed = JSON.parse(authState);
+      const evmWallet = parsed.wallet;
+      if (!evmWallet?.uid || !evmWallet?.sid || !evmWallet?.pvencstr || !evmWallet?.wid) {
+        throw new TronProviderError(
+          TronErrorCode.UNAUTHORIZED,
+          "EVM wallet data not found (required for TRON signing)"
+        );
+      }
+      console.log(
+        "[TronProvider] \u{1F510} Requesting PIN for TRON transaction..."
+      );
+      const pin = await this.requestPin();
+      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 SecureService = (await import("./abcWallet/secure.js")).default;
+      const secureService = new SecureService(this.client.tron.getBaseURL());
+      const walletData = {
+        address: evmWallet.address,
+        keyId: evmWallet.keyId,
+        encryptedShare: evmWallet.encryptedShare,
+        uid: evmWallet.uid,
+        sid: evmWallet.sid,
+        wid: evmWallet.wid,
+        pvencstr: evmWallet.pvencstr,
+        encryptDevicePassword: evmWallet.encryptDevicePassword,
+        pubkey: evmWallet.pubkey
+      };
+      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 txHash = await this.client.tron.sendTransaction(
+        {
+          fromAddress: this.wallet.address,
+          toAddress: params.toAddress,
+          amount: amountRaw,
+          network: this.network.type,
+          contractAddress: params.contractAddress,
+          feeLimit: params.feeLimit,
+          type: txType
+        },
+        walletData,
+        pinHash,
+        secureService
+      );
+      console.log("[TronProvider] \u2705 Transaction complete:", 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
+};