@talken/talkenkit 2.4.16 → 2.4.17

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

@@ -0,0 +1,182 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-XWVM2Y5A.js";
+import {
+  getNetworkName
+} from "./chunk-4PCVQBFZ.js";
+import {
+  createAbcError
+} from "./chunk-BLEKTKBN.js";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-OBS74J5N.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-LZZE462U.js

@@ -0,0 +1,315 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-25V3FW3O.js";
+import {
+  getSolanaNetwork
+} from "./chunk-O4AU63LK.js";
+import {
+  createAbcError
+} from "./chunk-GO6OLTNF.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+import { PublicKey } from "@solana/web3.js";
+import { getTalkenApiClient } from "@talken/talkenkit";
+var SolanaApi = class extends BaseApiClient {
+  /**
+   * Generate Solana wallet (Ed25519)
+   * Delegates to TalkenApiClient unified wallet endpoint.
+   *
+   * @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 api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const response = isRecover ? await api.wallet.recover(pin) : await api.wallet.generate(pin);
+    if (!response.solana) {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Solana wallet not returned from TalkenApiClient ${isRecover ? "recovery" : "generation"}`
+      );
+    }
+    return response.solana;
+  }
+  /**
+   * Recover Solana wallet (alias for generateSolanaWallet with isRecover=true)
+   * When TalkenApiClient is available, delegates to the unified recovery endpoint.
+   *
+   * @param pin - Hashed PIN (SHA-256)
+   * @returns Recovered Solana wallet information
+   */
+  async recoverSolanaWallet(pin) {
+    return this.generateSolanaWallet(pin, true);
+  }
+  /**
+   * Get Solana address from wallet addresses endpoint
+   * Retrieves from TalkenApiClient unified addresses endpoint.
+   *
+   * @returns Solana address string or null if not available
+   */
+  async getSolanaAddress() {
+    const api = getTalkenApiClient();
+    if (!api)
+      throw new Error("TalkenApiClient not initialized");
+    const addresses = await api.wallet.getAddresses();
+    return addresses.solana || null;
+  }
+  /**
+   * Derive Solana address from Ed25519 public key
+   * @param publicKey - Ed25519 public key (hex)
+   * @returns Solana address (base58)
+   */
+  deriveAddressFromPublicKey(publicKey) {
+    const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    const bytes = new Uint8Array(
+      cleanKey.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    try {
+      const pubkey = new PublicKey(bytes);
+      return pubkey.toBase58();
+    } catch (error) {
+      console.error("[SolanaApi] Failed to encode address:", error);
+      return cleanKey;
+    }
+  }
+  /**
+   * Sign Solana transaction with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaTransaction(params) {
+    const network = getSolanaNetwork();
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        network,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana transaction",
+        response
+      );
+    }
+    return {
+      signature
+    };
+  }
+  /**
+   * Sign Solana message with Ed25519
+   * Reference: /v3/wallet/sign API requires only 5 fields
+   */
+  async signSolanaMessage(params) {
+    const network = getSolanaNetwork();
+    const response = await this.request("/v3/wallet/sign", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        network,
+        key_id: params.keyId,
+        encrypted_share: params.encryptedShare,
+        secret_store: params.secretStore || "",
+        message: params.message
+      }
+    });
+    let signature;
+    if (response.status === "success" && response.result?.signature) {
+      signature = response.result.signature;
+    } else if (response.signature) {
+      signature = response.signature;
+    } else {
+      throw createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign Solana message",
+        response
+      );
+    }
+    return {
+      signature
+    };
+  }
+  /**
+   * Generate Solana transfer transaction via ABC WaaS API
+   * This ensures the transaction uses the same RPC and blockhash as the server
+   */
+  async generateTransferTransaction(params) {
+    const response = await this.request(
+      "/wapi/v2/solana/tx/generateTransferSOLTransaction",
+      {
+        method: "POST",
+        contentType: "json",
+        body: {
+          network: params.network,
+          amount: params.amount,
+          fromAddress: params.fromAddress,
+          toAddress: params.toAddress,
+          feePayerAddress: params.feePayerAddress
+        }
+      }
+    );
+    const responseData = response;
+    const serializedTx = responseData.data?.serialized_tx || response.status === "success" && response.result?.data?.serialized_tx;
+    if (!serializedTx) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to generate Solana transaction",
+        response
+      );
+    }
+    return {
+      serialized_tx: serializedTx
+    };
+  }
+  /**
+   * Send Solana transaction (unsigned transaction + separate signatures)
+   * Used for server-generated transactions that need client signatures
+   */
+  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
+      }
+    });
+    const responseData = response;
+    const txHash = responseData.data || response.status === "success" && response.result?.data;
+    if (!txHash || typeof txHash !== "string") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send Solana transaction",
+        response
+      );
+    }
+    return {
+      txHash
+    };
+  }
+  /**
+   * Send fully signed Solana transaction (for client-built transactions)
+   * Sends a completely signed transaction directly to Solana network
+   */
+  async sendSignedSolanaTransaction(params) {
+    const response = await this.request(
+      "/wapi/v2/solana/tx/sendSignedTransaction",
+      {
+        method: "POST",
+        contentType: "json",
+        body: {
+          network: params.network,
+          serializedTX: params.serializedTX
+        }
+      }
+    );
+    const responseData = response;
+    const txHash = responseData.data?.transactionHash || response.status === "success" && response.result?.data?.transactionHash;
+    if (!txHash || typeof txHash !== "string") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to send signed Solana transaction",
+        response
+      );
+    }
+    return {
+      txHash
+    };
+  }
+  /**
+   * Generate SPL token transfer transaction via ABC WaaS API
+   * Uses wallet addresses (not token accounts) - API resolves ATAs internally
+   *
+   * @param params - SPL transfer parameters
+   * @returns Serialized transaction
+   */
+  async generateSPLTransferTransaction(params) {
+    const response = await this.request(
+      "/wapi/v2/solana/tx/generateTransferFTTransaction",
+      {
+        method: "POST",
+        contentType: "json",
+        body: {
+          network: params.network,
+          mintAddress: params.mintAddress,
+          fromAddress: params.fromAddress,
+          toAddress: params.toAddress,
+          amount: params.amount,
+          ...params.decimals !== void 0 && { decimals: params.decimals },
+          ...params.feePayerAddress && {
+            feePayerAddress: params.feePayerAddress
+          },
+          ...params.latestBlockhash && {
+            latestBlockhash: params.latestBlockhash
+          }
+        }
+      }
+    );
+    const responseData = response;
+    const data = responseData.data || response.status === "success" && response.result;
+    if (!data?.serialized_tx) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to generate SPL transfer transaction",
+        response
+      );
+    }
+    return {
+      serialized_tx: data.serialized_tx,
+      estimated_fee: data.estimated_fee || { context: { Slot: 0 }, value: 0 },
+      latest_blockhash: data.latest_blockhash || ""
+    };
+  }
+  /**
+   * Get SPL token supply information
+   *
+   * @param params - Token query parameters
+   * @returns Token supply information
+   */
+  async getTokenInfo(params) {
+    const response = await this.request(
+      "/wapi/v2/solana/token/getTokenSupply",
+      {
+        method: "POST",
+        contentType: "json",
+        body: {
+          network: params.network,
+          tokenAddress: params.tokenAddress
+        }
+      }
+    );
+    const responseData = response;
+    const value = responseData.data?.value || response.status === "success" && response.result?.data?.value;
+    if (!value || typeof value.decimals !== "number") {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Failed to get token info",
+        response
+      );
+    }
+    return {
+      amount: value.amount,
+      decimals: value.decimals,
+      uiAmountString: value.uiAmountString
+    };
+  }
+};
+
+export {
+  SolanaApi
+};