@talken/talkenkit 2.3.12 → 2.3.13

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

@@ -0,0 +1,436 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-G2LI5MVX.js";
+import {
+  getSolanaNetwork
+} from "./chunk-AL7R7JQU.js";
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+import { Transaction, PublicKey } from "@solana/web3.js";
+
+// src/utils/encryption.ts
+async function hashPin(pin) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(pin);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+var AbcSolProvider = class {
+  constructor(address, walletData) {
+    this.name = "ABC WaaS";
+    this.publicKey = null;
+    this.walletData = null;
+    if (address) {
+      this.publicKey = new PublicKey(address);
+    }
+    if (walletData) {
+      this.walletData = walletData;
+    } else if (address) {
+      this.loadWalletDataFromStorage();
+    }
+    const baseURL = process.env.NEXT_PUBLIC_ABC_WAAS_URL || "";
+    this.secure = new secure_default(baseURL);
+  }
+  /**
+   * Set PIN request callback
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user via callback or global callback
+   */
+  async requestPin() {
+    if (this.requestPinCallback) {
+      return this.requestPinCallback();
+    }
+    const globalCallback = window.__TALKENKIT_REQUEST_PIN__;
+    if (globalCallback) {
+      return globalCallback("transaction");
+    }
+    throw new Error("PIN request callback not configured");
+  }
+  /**
+   * Load wallet data from localStorage
+   */
+  loadWalletDataFromStorage() {
+    try {
+      const authState = localStorage.getItem("talkenkit_abc_auth_state");
+      if (authState) {
+        const parsed = JSON.parse(authState);
+        if (parsed.solanaWallet) {
+          this.walletData = parsed.solanaWallet;
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  /**
+   * Get wallet data (from internal storage or localStorage)
+   */
+  getWalletData() {
+    if (this.walletData) {
+      return this.walletData;
+    }
+    const authState = localStorage.getItem("talkenkit_abc_auth_state");
+    if (authState) {
+      const parsed = JSON.parse(authState);
+      if (parsed.solanaWallet) {
+        const wallet = { ...parsed.solanaWallet };
+        if (!wallet.uid && parsed.user?.uid) {
+          wallet.uid = parsed.user.uid;
+        }
+        if (!wallet.shareId && wallet.key_id) {
+          wallet.shareId = wallet.key_id;
+        }
+        this.walletData = wallet;
+        return this.walletData;
+      }
+    }
+    throw new Error("No Solana wallet data available");
+  }
+  async signMessage(message, _encoding) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const messageHex = Buffer.from(message).toString("hex");
+    const signBody = {
+      curve: walletData.curve,
+      encrypted_share: walletData.encrypted_share,
+      key_id: walletData.key_id,
+      message: messageHex,
+      secret_store: walletData.secret_store
+    };
+    const apiUrl = `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`;
+    const requestBodyJson = JSON.stringify(signBody);
+    console.log("[AbcSolProvider] \u{1F680} signMessage request:", {
+      url: apiUrl,
+      messageLength: message.length,
+      messageHex: messageHex.substring(0, 64) + "...",
+      bodyKeys: Object.keys(signBody),
+      validation: {
+        hasCurve: !!signBody.curve,
+        hasEncryptedShare: !!signBody.encrypted_share,
+        hasKeyId: !!signBody.key_id,
+        hasMessage: !!signBody.message,
+        hasSecretStore: !!signBody.secret_store
+      },
+      fieldTypes: {
+        curve: typeof signBody.curve,
+        encrypted_share: typeof signBody.encrypted_share,
+        key_id: typeof signBody.key_id,
+        message: typeof signBody.message,
+        secret_store: typeof signBody.secret_store
+      },
+      fieldPreviews: {
+        curve: signBody.curve,
+        encrypted_share: signBody.encrypted_share?.substring(0, 50) + "...",
+        key_id: signBody.key_id?.substring(0, 50) + "...",
+        message: signBody.message?.substring(0, 50) + "...",
+        secret_store: signBody.secret_store?.substring(0, 50) + "..."
+      },
+      requestBodyLength: requestBodyJson.length,
+      requestBodyPreview: requestBodyJson.substring(0, 200) + "..."
+    });
+    const response = await fetch(
+      apiUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: requestBodyJson
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("[AbcSolProvider] \u274C Sign API error:", errorText);
+      throw new Error(`ABC WaaS sign failed: ${errorText}`);
+    }
+    const result = await response.json();
+    const signatureHex = result.result?.signature || result.signature || result.data?.signature;
+    if (!signatureHex) {
+      console.error("[AbcSolProvider] \u274C No signature in response:", result);
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    return { signature: signatureBytes };
+  }
+  async signTransaction(transaction, params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    let toAddress;
+    let amount;
+    if (params) {
+      toAddress = params.toAddress;
+      amount = params.amount * 1e9;
+    } else {
+      const transferInstruction = transaction.instructions[0];
+      toAddress = transferInstruction.keys[1]?.pubkey.toString();
+      amount = 1e5;
+    }
+    const solanaNetwork = getSolanaNetwork();
+    const requestBody = {
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress,
+      amount,
+      feePayerAddress: walletData.address
+      // Fee payer is the sender
+    };
+    const generateTxUrl = `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`;
+    console.log("[AbcSolProvider] \u{1F680} signTransaction request:", {
+      generateTxUrl,
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress,
+      amount,
+      walletDataKeys: Object.keys(walletData)
+    });
+    const txResponse = await fetch(
+      generateTxUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!txResponse.ok) {
+      const errorText = await txResponse.text();
+      console.error("[AbcSolProvider] \u274C API error:", errorText);
+      throw new Error(
+        `Transaction generation failed (${txResponse.status}): ${errorText}`
+      );
+    }
+    const txData = await txResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No serialized_tx in response:",
+        txData
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signUrl = `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`;
+    console.log("[AbcSolProvider] \u{1F680} signTransaction - signing:", {
+      signUrl,
+      serializedTxHexLength: serializedTxHex.length
+    });
+    const signResponse = await fetch(signUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        curve: walletData.curve,
+        encrypted_share: walletData.encrypted_share,
+        key_id: walletData.key_id,
+        message: serializedTxHex,
+        secret_store: walletData.secret_store
+      })
+    });
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign API error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const serializedTxBytes = new Uint8Array(
+      serializedTxHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const signedTransaction = Transaction.from(serializedTxBytes);
+    if (!signedTransaction.signatures || signedTransaction.signatures.length === 0) {
+      signedTransaction.addSignature(
+        this.publicKey,
+        Buffer.from(signatureBytes)
+      );
+    }
+    return signedTransaction;
+  }
+  /**
+   * Send (broadcast) signed Solana transaction to network
+   * - Transaction generation: v2 API (application/json)
+   * - Transaction signing: v3 API (Ed25519 MPC)
+   * - Transaction broadcast: v2 API
+   */
+  async sendTransaction(params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const pin = await this.requestPin();
+    const STORAGE_PREFIX = "talkenkit_abc_";
+    const storedPinHash = localStorage.getItem(`${STORAGE_PREFIX}pin_hash`);
+    if (!storedPinHash) {
+      throw new Error("PIN not set. Please login again.");
+    }
+    const enteredPinHash = await hashPin(pin);
+    if (enteredPinHash !== storedPinHash) {
+      throw new Error("Incorrect PIN. Transaction cancelled.");
+    }
+    const solanaNetwork = getSolanaNetwork();
+    const generateBody = {
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress: params.toAddress,
+      amount: params.amount * 1e9,
+      // Convert SOL to lamports
+      feePayerAddress: walletData.address
+      // Fee payer is the sender
+    };
+    const generateTxUrl = `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`;
+    console.log("[AbcSolProvider] \u{1F680} sendTransaction - Step 1: Generate TX:", {
+      url: generateTxUrl,
+      network: solanaNetwork,
+      fromAddress: walletData.address,
+      toAddress: params.toAddress,
+      amount: params.amount * 1e9,
+      walletDataKeys: Object.keys(walletData),
+      walletDataAddressType: typeof walletData.address
+    });
+    const generateResponse = await fetch(
+      generateTxUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(generateBody)
+      }
+    );
+    if (!generateResponse.ok) {
+      const errorText = await generateResponse.text();
+      console.error("[AbcSolProvider] \u274C Generate TX error:", errorText);
+      throw new Error(`Transaction generation failed: ${errorText}`);
+    }
+    const txData = await generateResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx || txData.result?.serialized_tx || txData.serialized_tx || txData.result?.data?.serializedTX || txData.data?.serializedTX;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C Cannot find serialized_tx in response:",
+        {
+          hasResult: !!txData.result,
+          hasData: !!txData.data,
+          hasResultData: !!txData.result?.data,
+          resultKeys: txData.result ? Object.keys(txData.result) : [],
+          dataKeys: txData.data ? Object.keys(txData.data) : [],
+          topLevelKeys: Object.keys(txData),
+          fullResponse: txData
+        }
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signBody = {
+      curve: walletData.curve,
+      encrypted_share: walletData.encrypted_share,
+      key_id: walletData.key_id,
+      message: serializedTxHex,
+      // HEX string
+      secret_store: walletData.secret_store
+    };
+    const signUrl = `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`;
+    console.log("[AbcSolProvider] \u{1F680} sendTransaction - Step 2: Sign TX:", {
+      url: signUrl,
+      serializedTxHexLength: serializedTxHex.length
+    });
+    const signResponse = await fetch(
+      signUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(signBody)
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.result?.signature || signResult.signature || signResult.data?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const broadcastUrl = `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/sendTransaction`;
+    console.log("[AbcSolProvider] \u{1F680} sendTransaction - Step 3: Broadcast TX:", {
+      url: broadcastUrl,
+      network: solanaNetwork,
+      signatureLength: signatureHex.length
+    });
+    const sendResponse = await fetch(broadcastUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        network: solanaNetwork,
+        serializedTX: serializedTxHex,
+        signatures: [signatureHex]
+      })
+    });
+    if (!sendResponse.ok) {
+      const errorText = await sendResponse.text();
+      console.error("[AbcSolProvider] \u274C Broadcast error:", {
+        status: sendResponse.status,
+        statusText: sendResponse.statusText,
+        error: errorText
+      });
+      try {
+        const errorData = JSON.parse(errorText);
+        if (errorData.message?.includes("insufficient") || errorData.message?.includes("InsufficientFunds")) {
+          throw new Error("Insufficient SOL balance to send transaction");
+        }
+      } catch (_parseError) {
+      }
+      throw new Error(
+        `Transaction broadcast failed (${sendResponse.status}): ${errorText}`
+      );
+    }
+    const sendResult = await sendResponse.json();
+    const txHash = sendResult.result?.data || sendResult.data || sendResult.txHash;
+    return {
+      signature: signatureHex,
+      txHash: txHash || signatureHex
+    };
+  }
+};
+
+export {
+  AbcSolProvider
+};

package/dist/wallets/walletConnectors/{chunk-XYPR4BAF.js → chunk-ZIYAL44B.js}

@@ -2,7 +2,7 @@
 import {
   hexToNumber,
   numberToHex
-} from "./chunk-W2VDZD74.js";
+} from "./chunk-UV5HHESJ.js";
 
 // src/wallets/walletConnectors/abcWallet/abcProvider.ts
 var EventEmitter = class {

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

@@ -0,0 +1,130 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/networkConfig.ts
+var ChainType = /* @__PURE__ */ ((ChainType2) => {
+  ChainType2["EVM"] = "evm";
+  ChainType2["Solana"] = "solana";
+  ChainType2["Bitcoin"] = "bitcoin";
+  return ChainType2;
+})(ChainType || {});
+var SolanaNetwork = /* @__PURE__ */ ((SolanaNetwork2) => {
+  SolanaNetwork2["Mainnet"] = "solana";
+  SolanaNetwork2["Devnet"] = "solana_devnet";
+  SolanaNetwork2["Testnet"] = "solana_testnet";
+  return SolanaNetwork2;
+})(SolanaNetwork || {});
+var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
+  BitcoinNetwork2["Mainnet"] = "bitcoin";
+  BitcoinNetwork2["Testnet"] = "bitcoin_testnet";
+  return BitcoinNetwork2;
+})(BitcoinNetwork || {});
+var DEFAULT_NETWORK_CONFIG = {
+  evm: {
+    mainnet: 1,
+    // Ethereum Mainnet
+    testnet: 11155111
+    // Sepolia Testnet
+  },
+  solana: {
+    mainnet: "solana" /* Mainnet */,
+    devnet: "solana_devnet" /* Devnet */
+  },
+  bitcoin: {
+    mainnet: "bitcoin" /* Mainnet */,
+    testnet: "bitcoin_testnet" /* Testnet */
+  }
+};
+function getEnvironment() {
+  if (typeof process === "undefined") {
+    return "development";
+  }
+  const env = process.env.NEXT_PUBLIC_ENVIRONMENT;
+  return env === "production" ? "production" : "development";
+}
+function getEvmNetwork(customChainId) {
+  if (customChainId !== void 0) {
+    return customChainId;
+  }
+  const environment = getEnvironment();
+  return environment === "production" ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
+}
+function getSolanaNetwork() {
+  const environment = getEnvironment();
+  return environment === "production" ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
+}
+function getBitcoinNetwork() {
+  const environment = getEnvironment();
+  return environment === "production" ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+}
+function getNetworkForChain(chainType) {
+  switch (chainType) {
+    case "solana" /* Solana */:
+      return getSolanaNetwork();
+    case "bitcoin" /* Bitcoin */:
+      return getBitcoinNetwork();
+    case "evm" /* EVM */:
+      return getEvmNetwork();
+  }
+}
+function isMainnet(chainType, network) {
+  switch (chainType) {
+    case "solana" /* Solana */:
+      return network === DEFAULT_NETWORK_CONFIG.solana.mainnet;
+    case "bitcoin" /* Bitcoin */:
+      return network === DEFAULT_NETWORK_CONFIG.bitcoin.mainnet;
+    case "evm" /* EVM */:
+      return network !== DEFAULT_NETWORK_CONFIG.evm.testnet;
+  }
+}
+function getNetworkDisplayName(chainType, network) {
+  switch (chainType) {
+    case "solana" /* Solana */:
+      if (network === "solana" /* Mainnet */)
+        return "Solana Mainnet";
+      if (network === "solana_devnet" /* Devnet */)
+        return "Solana Devnet";
+      if (network === "solana_testnet" /* Testnet */)
+        return "Solana Testnet";
+      return `Solana ${network}`;
+    case "bitcoin" /* Bitcoin */:
+      return network === "bitcoin" /* Mainnet */ ? "Bitcoin Mainnet" : "Bitcoin Testnet";
+    case "evm" /* EVM */: {
+      const evmNetwork = network;
+      if (evmNetwork === 1)
+        return "Ethereum Mainnet";
+      if (evmNetwork === 11155111)
+        return "Ethereum Sepolia";
+      if (evmNetwork === 137)
+        return "Polygon Mainnet";
+      if (evmNetwork === 80001)
+        return "Polygon Mumbai";
+      return `EVM Chain ${evmNetwork}`;
+    }
+  }
+}
+function isSolanaNetwork(value) {
+  return value === "solana" /* Mainnet */ || value === "solana_devnet" /* Devnet */ || value === "solana_testnet" /* Testnet */;
+}
+function isBitcoinNetwork(value) {
+  return value === "bitcoin" /* Mainnet */ || value === "bitcoin_testnet" /* Testnet */;
+}
+function isEvmNetwork(value) {
+  return typeof value === "number" && value > 0;
+}
+
+export {
+  ChainType,
+  SolanaNetwork,
+  BitcoinNetwork,
+  DEFAULT_NETWORK_CONFIG,
+  getEnvironment,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getBitcoinNetwork,
+  getNetworkForChain,
+  isMainnet,
+  getNetworkDisplayName,
+  isSolanaNetwork,
+  isBitcoinNetwork,
+  isEvmNetwork
+};