@talken/talkenkit 2.4.11 → 2.4.12

package/dist/index.js

@@ -30,7 +30,7 @@ import {
   isTestnet,
   networkToChainId,
   networks_exports
-} from "./chunk-7FKWLUOV.js";
+} from "./chunk-KZZG24U5.js";
 import "./chunk-DFWCI4QG.js";
 import {
   darkTheme
@@ -3213,7 +3213,7 @@ function setRainbowKitVersion({ version }) {
 }
 function useFingerprint() {
   const fingerprint = useCallback4(() => {
-    setRainbowKitVersion({ version: "2.4.11" });
+    setRainbowKitVersion({ version: "2.4.12" });
   }, []);
   useEffect12(() => {
     fingerprint();
@@ -12616,7 +12616,7 @@ function useBitcoinWallet() {
         });
         return;
       }
-      const { AbcBitcoinProvider, createAbcWaasApiClient: createAbcWaasApiClient2 } = await import("./abcWallet-PP2WTSDI.js");
+      const { AbcBitcoinProvider, createAbcWaasApiClient: createAbcWaasApiClient2 } = await import("./abcWallet-YOPLVWVE.js");
       const client = createAbcWaasApiClient2({
         waasUrl: process.env.NEXT_PUBLIC_ABC_WAAS_URL || "",
         plain: "",
@@ -12734,7 +12734,7 @@ function useSolanaWallet() {
         });
         return;
       }
-      const { AbcSolanaProvider, createAbcWaasApiClient: createAbcWaasApiClient2 } = await import("./abcWallet-PP2WTSDI.js");
+      const { AbcSolanaProvider, createAbcWaasApiClient: createAbcWaasApiClient2 } = await import("./abcWallet-YOPLVWVE.js");
       const client = createAbcWaasApiClient2({
         waasUrl: process.env.NEXT_PUBLIC_ABC_WAAS_URL || "",
         plain: "",

package/dist/wallets/walletConnectors/abcWallet/abcApi.d.ts

@@ -165,6 +165,17 @@ export declare class AbcWaasClient {
     sendRawTransaction(chainId: number, signedTransaction: string): Promise<{
         txHash: string;
     }>;
+    /**
+     * Estimate gas for EIP-1559 transaction
+     * Reference: ABC WaaS API docs - /wapi/v2/gas/estimate/eip1559
+     */
+    estimateGas(params: {
+        chainId: number;
+        from?: string;
+        to: string;
+        value?: string;
+        data?: string;
+    }): Promise<string>;
     /**
      * Get wallet info
      */

package/dist/wallets/walletConnectors/abcWallet/abcApi.js

@@ -2,7 +2,7 @@
 import {
   AbcWaasClient,
   createAbcWaasClient
-} from "../chunk-NUAZNCMH.js";
+} from "../chunk-UTRMKLD5.js";
 import "../chunk-4PCVQBFZ.js";
 import "../chunk-NDYGTKP5.js";
 import "../chunk-A7FIBI6X.js";

package/dist/wallets/walletConnectors/abcWallet/abcConnector.js

@@ -1,9 +1,9 @@
 "use client";
 import {
   abcConnector
-} from "../chunk-KKCRCQNN.js";
-import "../chunk-2NVHWZUE.js";
-import "../chunk-NUAZNCMH.js";
+} from "../chunk-NY2MBDVO.js";
+import "../chunk-UYFNIOUH.js";
+import "../chunk-UTRMKLD5.js";
 import "../chunk-4PCVQBFZ.js";
 import "../chunk-NDYGTKP5.js";
 import "../chunk-A7FIBI6X.js";

package/dist/wallets/walletConnectors/abcWallet/abcProvider.d.ts

@@ -95,6 +95,11 @@ export declare class AbcEvmProvider extends EventEmitter {
      * Add Ethereum chain
      */
     private wallet_addEthereumChain;
+    /**
+     * Estimate gas for transaction
+     * Uses ABC WaaS gas estimation API with fallback
+     */
+    private eth_estimateGas;
     /**
      * Check if connected
      */

package/dist/wallets/walletConnectors/abcWallet/abcProvider.js

@@ -3,7 +3,7 @@ import {
   AbcEvmProvider,
   createAbcEvmProvider,
   createAbcProvider
-} from "../chunk-2NVHWZUE.js";
+} from "../chunk-UYFNIOUH.js";
 import "../chunk-5RSS3SRV.js";
 import "../chunk-RQIUWXDF.js";
 import "../chunk-VETRBBA2.js";

package/dist/wallets/walletConnectors/abcWallet/abcSolanaWalletAdapter.js

@@ -5,7 +5,7 @@ import {
 import "../chunk-MPFE6GP2.js";
 import {
   createAbcWaasClient
-} from "../chunk-NUAZNCMH.js";
+} from "../chunk-UTRMKLD5.js";
 import "../chunk-4PCVQBFZ.js";
 import "../chunk-NDYGTKP5.js";
 import "../chunk-A7FIBI6X.js";

package/dist/wallets/walletConnectors/abcWallet/abcWallet.js

@@ -1,10 +1,10 @@
 "use client";
 import {
   abcWallet
-} from "../chunk-GZFBNALD.js";
-import "../chunk-KKCRCQNN.js";
-import "../chunk-2NVHWZUE.js";
-import "../chunk-NUAZNCMH.js";
+} from "../chunk-LVODOLXE.js";
+import "../chunk-NY2MBDVO.js";
+import "../chunk-UYFNIOUH.js";
+import "../chunk-UTRMKLD5.js";
 import "../chunk-4PCVQBFZ.js";
 import "../chunk-NDYGTKP5.js";
 import "../chunk-A7FIBI6X.js";

package/dist/wallets/walletConnectors/abcWallet/index.js

@@ -39,19 +39,19 @@ import "../chunk-KXEAFXAA.js";
 import "../chunk-MPFE6GP2.js";
 import {
   abcWallet
-} from "../chunk-GZFBNALD.js";
+} from "../chunk-LVODOLXE.js";
 import {
   abcConnector
-} from "../chunk-KKCRCQNN.js";
+} from "../chunk-NY2MBDVO.js";
 import {
   AbcEvmProvider,
   createAbcEvmProvider,
   createAbcProvider
-} from "../chunk-2NVHWZUE.js";
+} from "../chunk-UYFNIOUH.js";
 import {
   AbcWaasClient,
   createAbcWaasClient
-} from "../chunk-NUAZNCMH.js";
+} from "../chunk-UTRMKLD5.js";
 import "../chunk-4PCVQBFZ.js";
 import {
   secure_default

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

@@ -0,0 +1,47 @@
+"use client";
+import {
+  abcConnector
+} from "./chunk-PPTSQD3J.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/abcWallet.ts
+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 config = {
+    waasUrl,
+    apiKey: specificOptions?.apiKey,
+    plain: specificOptions?.plain || "",
+    // Deprecated - not used (secure.ts uses random generation)
+    environment: specificOptions?.environment || "development",
+    defaultChainId: specificOptions?.defaultChainId,
+    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
+    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
+    projectId
+  };
+  return {
+    id: ABC_WALLET_METADATA.id,
+    name: ABC_WALLET_METADATA.name,
+    rdns: ABC_WALLET_METADATA.rdns,
+    iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
+    iconBackground: ABC_WALLET_METADATA.iconBackground,
+    // Embedded wallet - no installation required
+    installed: void 0,
+    // No download URLs for embedded wallet
+    downloadUrls: void 0,
+    // Create connector - wrapper function required by Wallet type
+    createConnector: (_walletDetails) => abcConnector({ config }),
+    // Embedded wallet always available
+    hidden: () => false
+  };
+};
+
+export {
+  abcWallet
+};

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

@@ -0,0 +1,464 @@
+"use client";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-5RSS3SRV.js";
+
+// src/wallets/walletConnectors/abcWallet/abcProvider.ts
+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;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  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 ProviderRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "ProviderRpcError";
+  }
+};
+var ErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  CHAIN_DISCONNECTED: 4901,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var AbcEvmProvider = class extends EventEmitter {
+  constructor(client) {
+    super();
+    this.wallet = null;
+    this.chainId = 1;
+    // Default to Ethereum mainnet
+    this.connected = false;
+    this.client = client;
+  }
+  /**
+   * Set wallet information
+   */
+  setWallet(wallet) {
+    const previousAddress = this.wallet?.address;
+    const previousChainId = this.chainId;
+    this.wallet = wallet;
+    this.chainId = wallet.chainId;
+    this.connected = true;
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+    }
+    if (previousChainId !== wallet.chainId) {
+      this.emit("chainChanged", numberToHex(wallet.chainId));
+    }
+    this.emit("connect", { chainId: numberToHex(wallet.chainId) });
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.emit("disconnect", {
+      code: ErrorCode.DISCONNECTED,
+      message: "User disconnected"
+    });
+    this.emit("accountsChanged", []);
+  }
+  /**
+   * Set PIN request callback
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user
+   */
+  async requestPin() {
+    if (!this.requestPinCallback) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "PIN request callback not configured"
+      );
+    }
+    return this.requestPinCallback();
+  }
+  /**
+   * EIP-1193 request method
+   */
+  async request(args) {
+    const { method, params } = args;
+    switch (method) {
+      case "eth_requestAccounts":
+        return this.eth_requestAccounts();
+      case "eth_accounts":
+        return this.eth_accounts();
+      case "eth_chainId":
+        return this.eth_chainId();
+      case "eth_sendTransaction":
+      case "wallet_sendTransaction":
+        return this.eth_sendTransaction(params);
+      case "eth_signTransaction":
+        return this.eth_signTransaction(params);
+      case "personal_sign":
+        return this.personal_sign(params);
+      case "eth_sign":
+        return this.eth_sign(params);
+      case "eth_signTypedData":
+      case "eth_signTypedData_v3":
+      case "eth_signTypedData_v4":
+        return this.eth_signTypedData(params);
+      case "wallet_switchEthereumChain":
+        return this.wallet_switchEthereumChain(params);
+      case "wallet_addEthereumChain":
+        return this.wallet_addEthereumChain(params);
+      case "eth_estimateGas":
+        return this.eth_estimateGas(params);
+      case "eth_blockNumber":
+      case "eth_call":
+      case "eth_gasPrice":
+      case "eth_getBalance":
+      case "eth_getBlockByHash":
+      case "eth_getBlockByNumber":
+      case "eth_getCode":
+      case "eth_getStorageAt":
+      case "eth_getTransactionByHash":
+      case "eth_getTransactionCount":
+      case "eth_getTransactionReceipt":
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method ${method} should be handled by RPC provider`
+        );
+      default:
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method ${method} not supported`
+        );
+    }
+  }
+  /**
+   * Request accounts (EIP-1193)
+   */
+  async eth_requestAccounts() {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    return [this.wallet.address];
+  }
+  /**
+   * Get accounts
+   */
+  async eth_accounts() {
+    if (!this.wallet) {
+      return [];
+    }
+    return [this.wallet.address];
+  }
+  /**
+   * Get chain ID
+   */
+  async eth_chainId() {
+    return numberToHex(this.chainId);
+  }
+  /**
+   * Send transaction
+   */
+  async eth_sendTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid transaction params"
+      );
+    }
+    const tx = params[0];
+    const isContractDeployment = !tx.to || tx.to === "0x" || tx.to === "0x0" || tx.to === "0x0000000000000000000000000000000000000000";
+    if (isContractDeployment) {
+      tx.to = "0x";
+    } else if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        '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) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "Failed to get signed transaction from ABC WaaS"
+      );
+    }
+    const sendResult = await this.client.sendRawTransaction(
+      this.chainId,
+      signResult.signature
+      // serializedTx
+    );
+    return sendResult.txHash;
+  }
+  /**
+   * Sign transaction (without sending)
+   */
+  async eth_signTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid transaction 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);
+    return result.signature;
+  }
+  /**
+   * Personal sign (EIP-191)
+   */
+  async personal_sign(params) {
+    if (!this.wallet) {
+      console.error("[AbcProvider] \u274C Wallet not connected");
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      console.error("[AbcProvider] \u274C Invalid params:", params);
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid personal_sign params"
+      );
+    }
+    const [message, address] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      console.error("[AbcProvider] \u274C Address mismatch");
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "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({
+      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
+    });
+    return result.signature;
+  }
+  /**
+   * Eth sign
+   */
+  async eth_sign(params) {
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid eth_sign params"
+      );
+    }
+    const [address, message] = params;
+    return this.personal_sign([message, address]);
+  }
+  /**
+   * Sign typed data (EIP-712)
+   */
+  async eth_signTypedData(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid signTypedData params"
+      );
+    }
+    const [address, typedData] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "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
+    });
+    return result.signature;
+  }
+  /**
+   * Switch Ethereum chain
+   */
+  async wallet_switchEthereumChain(params) {
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid switchEthereumChain params"
+      );
+    }
+    const { chainId } = params[0];
+    const newChainId = hexToNumber(chainId);
+    if (this.chainId === newChainId) {
+      return null;
+    }
+    const _previousChainId = this.chainId;
+    this.chainId = newChainId;
+    if (this.wallet) {
+      this.wallet.chainId = newChainId;
+    }
+    this.emit("chainChanged", numberToHex(newChainId));
+    return null;
+  }
+  /**
+   * Add Ethereum chain
+   */
+  async wallet_addEthereumChain(params) {
+    return this.wallet_switchEthereumChain(params);
+  }
+  /**
+   * Estimate gas for transaction
+   * Uses ABC WaaS gas estimation API
+   */
+  async eth_estimateGas(params) {
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid estimateGas params"
+      );
+    }
+    const tx = params[0];
+    if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        'Transaction must have "to" field'
+      );
+    }
+    const gasLimit = await this.client.estimateGas({
+      chainId: this.chainId,
+      from: tx.from || this.wallet?.address,
+      to: tx.to,
+      value: tx.value,
+      data: tx.data
+    });
+    return gasLimit;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get current chain ID
+   */
+  getChainId() {
+    return this.chainId;
+  }
+};
+function createAbcEvmProvider(client) {
+  return new AbcEvmProvider(client);
+}
+var createAbcProvider = createAbcEvmProvider;
+
+export {
+  AbcEvmProvider,
+  createAbcEvmProvider,
+  createAbcProvider
+};