@talken/talkenkit 2.3.4 → 2.3.5

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Rainbow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.js

@@ -10,14 +10,14 @@ import {
   secure_default
 } from "./chunk-Y7ZSI2YC.js";
 import {
-  lightTheme
-} from "./chunk-72HZGUJA.js";
+  darkTheme
+} from "./chunk-RZWDCITT.js";
 import {
   midnightTheme
 } from "./chunk-7ZP3ENJ2.js";
 import {
-  darkTheme
-} from "./chunk-RZWDCITT.js";
+  lightTheme
+} from "./chunk-72HZGUJA.js";
 import "./chunk-DQLAW7KN.js";
 import {
   en_US_default
@@ -2114,7 +2114,7 @@ function setRainbowKitVersion({ version }) {
 }
 function useFingerprint() {
   const fingerprint = useCallback3(() => {
-    setRainbowKitVersion({ version: "2.3.4" });
+    setRainbowKitVersion({ version: "2.3.5" });
   }, []);
   useEffect10(() => {
     fingerprint();
@@ -5626,6 +5626,7 @@ var AbcWaasClient = class {
     };
     const network = networkMap[params.chainId] || "ethereum";
     const tx = params.transaction;
+    const isKaiaNetwork = params.chainId === 1001 || params.chainId === 8217;
     if (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas || !tx.gasLimit || !tx.gas) {
       try {
         if (!tx.maxFeePerGas || !tx.maxPriorityFeePerGas) {
@@ -5683,22 +5684,66 @@ var AbcWaasClient = class {
             response: estimateData
           });
           if (estimateResponse.ok && estimateData.result) {
-            tx.gasLimit = estimateData.result;
-            console.log("\u2705 Gas limit from estimate:", estimateData.result);
+            const estimatedGas = estimateData.result;
+            const estimatedGasNumber = Number.parseInt(estimatedGas, 16);
+            if (isKaiaNetwork) {
+              const hasContractData = tx.data && tx.data !== "0x" && tx.data.length > 2;
+              const minGas = hasContractData ? 1e5 : 21e3;
+              if (estimatedGasNumber < minGas) {
+                console.warn(
+                  "\u26A0\uFE0F [Kaia] Gas estimate too low, enforcing minimum:",
+                  {
+                    chainId: params.chainId,
+                    estimated: estimatedGas,
+                    estimatedDecimal: estimatedGasNumber,
+                    minimum: minGas,
+                    isContractCall: hasContractData
+                  }
+                );
+                tx.gasLimit = `0x${minGas.toString(16)}`;
+              } else {
+                const bufferedGas = Math.floor(estimatedGasNumber * 1.2);
+                tx.gasLimit = `0x${bufferedGas.toString(16)}`;
+                console.log("\u2705 [Kaia] Gas limit with 20% buffer:", {
+                  estimated: estimatedGas,
+                  buffered: tx.gasLimit
+                });
+              }
+            } else {
+              tx.gasLimit = estimatedGas;
+              console.log("\u2705 Gas limit from estimate:", estimatedGas);
+            }
           } else {
-            const fallbackGasLimit = "0x2dc6c0";
-            tx.gasLimit = fallbackGasLimit;
-            console.warn("\u26A0\uFE0F Gas estimate failed, using fallback:", {
-              error: estimateData.errorMessage || estimateData.msg,
-              fallbackGasLimit
-            });
+            const hasContractData = tx.data && tx.data !== "0x" && tx.data.length > 2;
+            if (hasContractData) {
+              tx.gasLimit = isKaiaNetwork ? "0x186a0" : "0x249f0";
+              console.warn(
+                "\u26A0\uFE0F Gas estimate failed, using contract call fallback:",
+                {
+                  chainId: params.chainId,
+                  network,
+                  fallbackGasLimit: tx.gasLimit,
+                  isKaia: isKaiaNetwork,
+                  error: estimateData.errorMessage || estimateData.msg
+                }
+              );
+            } else {
+              tx.gasLimit = "0x5208";
+              console.warn(
+                "\u26A0\uFE0F Gas estimate failed, using native transfer fallback:",
+                {
+                  chainId: params.chainId,
+                  network,
+                  fallbackGasLimit: tx.gasLimit
+                }
+              );
+            }
           }
         }
       } catch (error3) {
         console.warn("Failed to fetch gas parameters from ABC WaaS:", error3);
       }
     }
-    const isContractDeployment = !params.transaction.to || params.transaction.to === "0x" || params.transaction.to === "0x0";
     const bodyData = {
       network,
       encryptDevicePassword: encryptedDevicePassword,
@@ -5711,6 +5756,7 @@ var AbcWaasClient = class {
       // Reference: talken-nft-drops/src/libs/abc-waas-provider/index.ts:800 - to: to ?? '0x'
       to: tx.to === "0x" ? "0x" : getAddress(tx.to),
       // Required by ABC WaaS API
+      // Always use EIP1559 type (ABC WaaS handles network-specific conversion)
       type: "EIP1559",
       // ourpubkey and ucpubkey are required by ABC WaaS (empty strings for now)
       // Based on successful tg-wallet payload analysis
@@ -5724,6 +5770,8 @@ var AbcWaasClient = class {
         hexValue = `0${hexValue}`;
       }
       bodyData.value = `0x${hexValue}`;
+    } else {
+      bodyData.value = "0x0";
     }
     if (tx.gasLimit || tx.gas) {
       const gasLimitValue = tx.gasLimit || tx.gas;
@@ -5747,20 +5795,18 @@ var AbcWaasClient = class {
         bodyData.maxPriorityFeePerGas = `0x${BigInt(tx.maxPriorityFeePerGas).toString(16)}`;
       }
     }
+    if (tx.gasPrice) {
+      if (tx.gasPrice.toString().startsWith("0x")) {
+        bodyData.gasPrice = tx.gasPrice.toString();
+      } else {
+        bodyData.gasPrice = `0x${BigInt(tx.gasPrice).toString(16)}`;
+      }
+    }
     if (tx.data !== void 0 && tx.data !== null) {
       bodyData.data = tx.data || "0x";
     } else {
       bodyData.data = "0x";
     }
-    console.log("\u{1F50D} ABC WaaS signTransaction params:", {
-      isContractDeployment,
-      hasTo: !!bodyData.to,
-      to: bodyData.to,
-      dataLength: bodyData.data?.length,
-      network: bodyData.network,
-      type: bodyData.type,
-      allKeys: Object.keys(bodyData)
-    });
     const bodyString = new URLSearchParams(bodyData).toString();
     const url = `${this.baseURL}${ABC_ENDPOINTS.SIGN_TRANSACTION}`;
     const response = await fetch(url, {

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

@@ -2,7 +2,7 @@
 import {
   AbcWaasClient,
   createAbcWaasClient
-} from "../chunk-RWIZ25FJ.js";
+} from "../chunk-3DPCIDW6.js";
 import "../chunk-G2LI5MVX.js";
 import "../chunk-W23N7VC4.js";
 import "../chunk-VETRBBA2.js";

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

@@ -1,8 +1,8 @@
 "use client";
 import {
   abcConnector
-} from "../chunk-HD6YCICR.js";
-import "../chunk-RWIZ25FJ.js";
+} from "../chunk-X4CDP7L7.js";
+import "../chunk-3DPCIDW6.js";
 import "../chunk-G2LI5MVX.js";
 import "../chunk-73B7HWCT.js";
 import "../chunk-W23N7VC4.js";

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

@@ -1,10 +1,10 @@
 "use client";
 import {
   abcSolanaWallet
-} from "../chunk-QPAE4SDS.js";
+} from "../chunk-KOT7JYJR.js";
 import "../chunk-AEQOPQL6.js";
 import "../chunk-MY5YIDOB.js";
-import "../chunk-RWIZ25FJ.js";
+import "../chunk-3DPCIDW6.js";
 import "../chunk-G2LI5MVX.js";
 import "../chunk-W23N7VC4.js";
 import "../chunk-VETRBBA2.js";

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

@@ -1,9 +1,9 @@
 "use client";
 import {
   abcWallet
-} from "../chunk-JRNBDHFL.js";
-import "../chunk-HD6YCICR.js";
-import "../chunk-RWIZ25FJ.js";
+} from "../chunk-CSWWNAYR.js";
+import "../chunk-X4CDP7L7.js";
+import "../chunk-3DPCIDW6.js";
 import "../chunk-G2LI5MVX.js";
 import "../chunk-73B7HWCT.js";
 import "../chunk-W23N7VC4.js";

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

@@ -19,7 +19,7 @@ import "../chunk-KD2OAMDA.js";
 import "../chunk-IOLHAU7H.js";
 import {
   abcSolanaWallet
-} from "../chunk-QPAE4SDS.js";
+} from "../chunk-KOT7JYJR.js";
 import {
   AbcBitcoinConnector,
   createAbcBitcoinConnector
@@ -43,14 +43,14 @@ import {
 } from "../chunk-MY5YIDOB.js";
 import {
   abcWallet
-} from "../chunk-JRNBDHFL.js";
+} from "../chunk-CSWWNAYR.js";
 import {
   abcConnector
-} from "../chunk-HD6YCICR.js";
+} from "../chunk-X4CDP7L7.js";
 import {
   AbcWaasClient,
   createAbcWaasClient
-} from "../chunk-RWIZ25FJ.js";
+} from "../chunk-3DPCIDW6.js";
 import {
   secure_default
 } from "../chunk-G2LI5MVX.js";

package/dist/wallets/walletConnectors/chunk-2J66VMY5.js

@@ -0,0 +1,152 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-WAO3KL5U.js";
+import {
+  createAbcError
+} from "./chunk-W2VDZD74.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+var SolanaApi = class extends BaseApiClient {
+  /**
+   * Generate Solana wallet (Ed25519)
+   * Uses V3 API with Ed25519 curve
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @param isRecover - Whether to recover existing wallet (default: false)
+   * @returns Solana wallet information
+   */
+  async generateSolanaWallet(pin, isRecover = false) {
+    const endpoint = `/v3/wallet/${isRecover ? "recover" : "generate"}`;
+    console.log(
+      `[SolanaApi] \u{1F527} ${isRecover ? "Recovering" : "Generating"} Solana wallet...`
+    );
+    const response = await this.request(endpoint, {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        password: pin,
+        network: "solana"
+      }
+    });
+    if (response.status !== "success" || !response.result) {
+      console.error("[SolanaApi] \u274C Operation failed:", response);
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
+        response
+      );
+    }
+    const result = response.result;
+    const address = this.deriveAddressFromPublicKey(result.public_key);
+    console.log("[SolanaApi] \u2705 Wallet ready:", address);
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address,
+      keyId: result.key_id || result.share_id,
+      encryptedShare: result.encrypted_share || ""
+    };
+  }
+  /**
+   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @returns Recovered Solana wallet information
+   */
+  async recoverSolanaWallet(pin) {
+    return this.generateSolanaWallet(pin, true);
+  }
+  /**
+   * Derive Solana address from Ed25519 public key
+   * Converts hex public key to base58-encoded Solana address
+   *
+   * @param publicKey - Ed25519 public key (hex)
+   * @returns Solana address (base58)
+   */
+  deriveAddressFromPublicKey(publicKey) {
+    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    return cleanKey;
+  }
+  /**
+   * Sign Solana transaction with Ed25519
+   */
+  async signSolanaTransaction(params) {
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        uid: params.uid,
+        share_id: params.shareId,
+        message: params.message,
+        password: params.pin
+      }
+    });
+    if (response.status !== "success" || !response.result?.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction",
+        response
+      );
+    }
+    return {
+      signature: response.result.signature
+    };
+  }
+  /**
+   * Sign Solana message with Ed25519
+   */
+  async signSolanaMessage(params) {
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        uid: params.uid,
+        share_id: params.shareId,
+        message: params.message,
+        password: params.pin
+      }
+    });
+    if (response.status !== "success" || !response.result?.signature) {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message",
+        response
+      );
+    }
+    return {
+      signature: response.result.signature
+    };
+  }
+  /**
+   * Send Solana transaction
+   */
+  async sendSolanaTransaction(params) {
+    const response = await this.request("/wapi/v2/solana/tx/sendTransaction", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        network: params.network,
+        serializedTX: params.serializedTX,
+        signatures: params.signatures
+      }
+    });
+    if (response.status !== "success" || !response.result?.data) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Solana transaction",
+        response
+      );
+    }
+    return {
+      txHash: response.result.data
+    };
+  }
+};
+
+export {
+  SolanaApi
+};

package/dist/wallets/walletConnectors/chunk-2W6UBYKX.js

@@ -0,0 +1,66 @@
+"use client";
+import {
+  isAndroid
+} from "./chunk-RETKWSKD.js";
+import {
+  getInjectedConnector
+} from "./chunk-MBBGZGXF.js";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+
+// src/wallets/walletConnectors/iopayWallet/iopayWallet.ts
+function isIoPayMobile() {
+  return typeof navigator !== "undefined" && typeof navigator.userAgent !== "undefined" && (navigator?.userAgent.includes("IoPayAndroid") || navigator?.userAgent.includes("IoPayiOs"));
+}
+var iopayWallet = ({
+  projectId,
+  walletConnectParameters
+}) => ({
+  id: "iopay",
+  name: "ioPay Wallet",
+  iconUrl: async () => (await import("./iopayWallet-IJHJ7NYT.js")).default,
+  iconBackground: "#fff",
+  downloadUrls: {
+    android: "https://play.google.com/store/apps/details?id=io.iotex.iopay.gp&pli=1",
+    ios: "https://apps.apple.com/us/app/iopay-multichain-crypto-wallet/id1478086371",
+    qrCode: "https://iopay.me/",
+    browserExtension: "https://iopay.me/"
+  },
+  mobile: {
+    getUri: (uri) => {
+      return isAndroid() ? uri : `iopay://wc?uri=${encodeURIComponent(uri)}`;
+    }
+  },
+  qrCode: {
+    getUri: (uri) => uri,
+    instructions: {
+      learnMoreUrl: "https://iopay.me/",
+      steps: [
+        {
+          description: "wallet_connectors.iopay.qr_code.step1.description",
+          step: "install",
+          title: "wallet_connectors.iopay.qr_code.step1.title"
+        },
+        {
+          description: "wallet_connectors.iopay.qr_code.step2.description",
+          step: "create",
+          title: "wallet_connectors.iopay.qr_code.step2.title"
+        },
+        {
+          description: "wallet_connectors.iopay.qr_code.step3.description",
+          step: "scan",
+          title: "wallet_connectors.iopay.qr_code.step3.title"
+        }
+      ]
+    }
+  },
+  createConnector: isIoPayMobile() ? getInjectedConnector({}) : getWalletConnectConnector({
+    projectId,
+    walletConnectParameters
+  })
+});
+
+export {
+  iopayWallet
+};

package/dist/wallets/walletConnectors/chunk-2ZPGPZCP.js

@@ -0,0 +1,228 @@
+"use client";
+import {
+  createAbcEvmProvider
+} from "./chunk-73B7HWCT.js";
+import {
+  createAbcWaasClient
+} from "./chunk-4HKJ53H3.js";
+import {
+  clearAuthState,
+  clearEncryptedTokens,
+  loadAuthState,
+  saveAuthState
+} from "./chunk-W23N7VC4.js";
+
+// src/wallets/walletConnectors/abcWallet/abcConnector.ts
+import { createConnector } from "wagmi";
+function abcConnector(options) {
+  const { config } = options;
+  return createConnector((wagmiConfig) => {
+    const client = createAbcWaasClient(config);
+    const provider = createAbcEvmProvider(client);
+    let accountsChangedHandler;
+    let chainChangedHandler;
+    let disconnectHandler;
+    return {
+      id: "abc",
+      name: "ABC Wallet",
+      type: "abc",
+      /**
+       * Connect wallet
+       */
+      async connect() {
+        try {
+          const authState = loadAuthState();
+          console.log("\u{1F527} ABC Connector connect() called:", {
+            hasAuthState: !!authState,
+            isAuthenticated: authState?.isAuthenticated,
+            hasWallet: !!authState?.wallet,
+            walletAddress: authState?.wallet?.address
+          });
+          if (!authState || !authState.isAuthenticated || !authState.wallet) {
+            throw new Error("ABC_LOGIN_REQUIRED");
+          }
+          provider.setWallet(authState.wallet);
+          console.log("\u2705 Provider wallet set:", {
+            address: authState.wallet.address,
+            hasPIN: !!authState.pin
+          });
+          const accounts = await provider.request({
+            method: "eth_requestAccounts"
+          });
+          const currentChainId = await provider.request({
+            method: "eth_chainId"
+          });
+          if (accountsChangedHandler) {
+            provider.removeListener("accountsChanged", accountsChangedHandler);
+          }
+          accountsChangedHandler = (accounts2) => {
+            wagmiConfig.emitter.emit("change", {
+              accounts: accounts2
+            });
+          };
+          provider.on("accountsChanged", accountsChangedHandler);
+          if (chainChangedHandler) {
+            provider.removeListener("chainChanged", chainChangedHandler);
+          }
+          chainChangedHandler = (chainId) => {
+            wagmiConfig.emitter.emit("change", {
+              chainId: Number(chainId)
+            });
+          };
+          provider.on("chainChanged", chainChangedHandler);
+          if (disconnectHandler) {
+            provider.removeListener("disconnect", disconnectHandler);
+          }
+          disconnectHandler = () => {
+            wagmiConfig.emitter.emit("disconnect");
+            this.onDisconnect();
+          };
+          provider.on("disconnect", disconnectHandler);
+          return {
+            accounts,
+            chainId: Number(currentChainId)
+          };
+        } catch (error) {
+          if (error.message === "ABC_LOGIN_REQUIRED") {
+            throw error;
+          }
+          throw error;
+        }
+      },
+      /**
+       * Disconnect wallet
+       */
+      async disconnect() {
+        if (accountsChangedHandler) {
+          provider.removeListener("accountsChanged", accountsChangedHandler);
+          accountsChangedHandler = void 0;
+        }
+        if (chainChangedHandler) {
+          provider.removeListener("chainChanged", chainChangedHandler);
+          chainChangedHandler = void 0;
+        }
+        if (disconnectHandler) {
+          provider.removeListener("disconnect", disconnectHandler);
+          disconnectHandler = void 0;
+        }
+        provider.clearWallet();
+        await client.logout();
+        let savedPinHash = null;
+        let savedEmail = null;
+        if (typeof window !== "undefined") {
+          savedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+          savedEmail = localStorage.getItem("talkenkit_abc_saved_email");
+        }
+        clearAuthState();
+        clearEncryptedTokens();
+        if (typeof window !== "undefined") {
+          localStorage.removeItem("talkenkit_abc_enc_salt");
+          localStorage.removeItem("talkenkit_abc_enc_tokens");
+          if (savedPinHash) {
+            localStorage.setItem("talkenkit_abc_pin_hash", savedPinHash);
+          }
+          if (savedEmail) {
+            localStorage.setItem("talkenkit_abc_saved_email", savedEmail);
+          }
+        }
+        console.log("\u2705 ABC Wallet disconnected (PIN preserved)");
+      },
+      /**
+       * Get accounts
+       */
+      async getAccounts() {
+        const accounts = await provider.request({
+          method: "eth_accounts"
+        });
+        return accounts.map((account) => account);
+      },
+      /**
+       * Get chain ID
+       */
+      async getChainId() {
+        const chainId = await provider.request({
+          method: "eth_chainId"
+        });
+        return Number(chainId);
+      },
+      /**
+       * Get provider
+       */
+      async getProvider() {
+        return provider;
+      },
+      /**
+       * Check if authorized (has valid session)
+       */
+      async isAuthorized() {
+        try {
+          const authState = loadAuthState();
+          if (!authState || !authState.isAuthenticated) {
+            return false;
+          }
+          return client.isAuthenticated();
+        } catch {
+          return false;
+        }
+      },
+      /**
+       * Switch chain
+       */
+      async switchChain({ chainId }) {
+        await provider.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: `0x${chainId.toString(16)}` }]
+        });
+        const newChainId = await this.getChainId();
+        const authState = loadAuthState();
+        if (authState?.wallet) {
+          authState.wallet.chainId = newChainId;
+          saveAuthState(authState);
+        }
+        return wagmiConfig.chains.find((x) => x.id === chainId) ?? {
+          id: chainId,
+          name: `Chain ${chainId}`,
+          nativeCurrency: {
+            name: "Ether",
+            decimals: 18,
+            symbol: "ETH"
+          },
+          rpcUrls: {
+            default: { http: [""] }
+          }
+        };
+      },
+      /**
+       * Handle accounts changed
+       */
+      onAccountsChanged(accounts) {
+        if (accounts.length === 0) {
+          this.onDisconnect();
+        } else {
+          wagmiConfig.emitter.emit("change", {
+            accounts
+          });
+        }
+      },
+      /**
+       * Handle chain changed
+       */
+      onChainChanged(chain) {
+        const chainId = Number(chain);
+        wagmiConfig.emitter.emit("change", { chainId });
+      },
+      /**
+       * Handle disconnect
+       */
+      onDisconnect(_error) {
+        provider.clearWallet();
+        clearAuthState();
+        wagmiConfig.emitter.emit("disconnect");
+      }
+    };
+  });
+}
+
+export {
+  abcConnector
+};