@talken/talkenkit 2.4.13 → 2.4.14

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

@@ -67,11 +67,15 @@ export declare class AbcSolanaProvider extends EventEmitter {
         signature: Uint8Array;
     }>;
     /**
-     * Sign Solana transaction (not used - ABC WaaS handles signing server-side)
-     * This method is kept for compatibility but not recommended for direct use
-     * Use the high-level sendTransaction() flow instead
+     * Sign arbitrary Solana transaction (requires PIN)
+     * Supports both Legacy Transaction and VersionedTransaction
+     * Used for custom transactions, dApp interactions, and protocol integrations
      */
-    signTransaction(_transaction: any, _params?: any): Promise<any>;
+    signTransaction<T>(transaction: T): Promise<T>;
+    /**
+     * Sign multiple transactions (batch signing)
+     */
+    signAllTransactions<T>(transactions: T[]): Promise<T[]>;
     /**
      * Send Solana transaction (with PIN verification)
      */
@@ -90,5 +94,49 @@ export declare class AbcSolanaProvider extends EventEmitter {
         publicKey: string;
         network: string;
     } | null;
+    /**
+     * Transfer SPL token (requires PIN)
+     *
+     * @param params - Transfer parameters
+     * @returns Transaction signature and serialized transaction
+     */
+    transferSPL(params: {
+        mintAddress: string;
+        toAddress: string;
+        amount: number;
+        createAccountIfNeeded?: boolean;
+    }): Promise<{
+        signature: string;
+        serializedTx?: string;
+    }>;
+    /**
+     * Transfer NFT (Solana NFT = SPL token with decimals: 0, amount: 1)
+     *
+     * @param params - Transfer parameters
+     * @returns Transaction signature and serialized transaction
+     */
+    transferNFT(params: {
+        mintAddress: string;
+        toAddress: string;
+        createAccountIfNeeded?: boolean;
+    }): Promise<{
+        signature: string;
+        serializedTx?: string;
+    }>;
+    /**
+     * Get SPL token balance
+     *
+     * @param mintAddress - Token mint address
+     * @returns Token balance information
+     */
+    getTokenBalance(mintAddress: string): Promise<{
+        amount: string;
+        decimals: number;
+        uiAmount: number;
+    }>;
+    /**
+     * Get RPC URL based on network
+     */
+    private getRpcUrl;
 }
 export {};

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

@@ -2,7 +2,7 @@
 import {
   AbcSolanaProvider,
   SolanaProviderError
-} from "../chunk-BH2VZAMQ.js";
+} from "../chunk-UCKLTSEQ.js";
 export {
   AbcSolanaProvider,
   SolanaProviderError

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

@@ -1,7 +1,7 @@
 "use client";
 import {
   SolanaApi
-} from "../chunk-KXEAFXAA.js";
+} from "../chunk-D3USECVX.js";
 import "../chunk-MPFE6GP2.js";
 import {
   createAbcWaasClient

package/dist/wallets/walletConnectors/abcWallet/api/SolanaApi.d.ts

@@ -55,9 +55,60 @@ export declare class SolanaApi extends BaseApiClient {
         serialized_tx: string;
     }>;
     /**
-     * Send Solana transaction
+     * Send Solana transaction (unsigned transaction + separate signatures)
+     * Used for server-generated transactions that need client signatures
      */
     sendSolanaTransaction(params: AbcSendSolanaTransactionParams): Promise<{
         txHash: string;
     }>;
+    /**
+     * Send fully signed Solana transaction (for client-built transactions)
+     * Sends a completely signed transaction directly to Solana network
+     */
+    sendSignedSolanaTransaction(params: {
+        network: string;
+        serializedTX: string;
+    }): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * 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
+     */
+    generateSPLTransferTransaction(params: {
+        network: string;
+        mintAddress: string;
+        fromAddress: string;
+        toAddress: string;
+        amount: number;
+        decimals?: number;
+        feePayerAddress?: string;
+        latestBlockhash?: string;
+    }): Promise<{
+        serialized_tx: string;
+        estimated_fee: {
+            context: {
+                Slot: number;
+            };
+            value: number;
+        };
+        latest_blockhash: string;
+    }>;
+    /**
+     * Get SPL token supply information
+     *
+     * @param params - Token query parameters
+     * @returns Token supply information
+     */
+    getTokenInfo(params: {
+        network: string;
+        tokenAddress: string;
+    }): Promise<{
+        amount: string;
+        decimals: number;
+        uiAmountString: string;
+    }>;
 }

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

@@ -1,7 +1,7 @@
 "use client";
 import {
   SolanaApi
-} from "../../chunk-KXEAFXAA.js";
+} from "../../chunk-D3USECVX.js";
 import "../../chunk-MPFE6GP2.js";
 import "../../chunk-NDYGTKP5.js";
 import "../../chunk-A7FIBI6X.js";

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

@@ -2,13 +2,13 @@
 import {
   AbcWaasApiClient,
   createAbcWaasApiClient
-} from "../../chunk-57YTMSPW.js";
-import {
-  TransactionApi
-} from "../../chunk-DJKN2MCI.js";
+} from "../../chunk-VP6SWGCN.js";
 import {
   WalletApi
 } from "../../chunk-V33I7JGZ.js";
+import {
+  TransactionApi
+} from "../../chunk-DJKN2MCI.js";
 import {
   AuthApi
 } from "../../chunk-ZNBWRE3K.js";
@@ -20,7 +20,7 @@ import {
 } from "../../chunk-7VZDITAJ.js";
 import {
   SolanaApi
-} from "../../chunk-KXEAFXAA.js";
+} from "../../chunk-D3USECVX.js";
 import {
   BaseApiClient
 } from "../../chunk-MPFE6GP2.js";

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

@@ -2,9 +2,9 @@
 import {
   AbcWaasApiClient,
   createAbcWaasApiClient
-} from "../chunk-57YTMSPW.js";
-import "../chunk-DJKN2MCI.js";
+} from "../chunk-VP6SWGCN.js";
 import "../chunk-V33I7JGZ.js";
+import "../chunk-DJKN2MCI.js";
 import {
   generateMpcWallets,
   recoverMpcWallets,
@@ -34,8 +34,8 @@ import {
 import {
   AbcSolanaProvider,
   SolanaProviderError
-} from "../chunk-BH2VZAMQ.js";
-import "../chunk-KXEAFXAA.js";
+} from "../chunk-UCKLTSEQ.js";
+import "../chunk-D3USECVX.js";
 import "../chunk-MPFE6GP2.js";
 import {
   abcWallet

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

@@ -290,9 +290,9 @@ export interface AbcSignSolanaMessageParamsV3 {
 export interface AbcSendSolanaTransactionParams {
     /** Network (mainnet or devnet) */
     network: string;
-    /** Serialized transaction (hex) */
+    /** Serialized transaction (base64 encoded) */
     serializedTX: string;
-    /** Signatures array (hex) */
+    /** Signature array */
     signatures: string[];
 }
 /**

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

@@ -0,0 +1,330 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-MPFE6GP2.js";
+import {
+  getSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
+import {
+  createAbcError
+} from "./chunk-5RSS3SRV.js";
+
+// src/wallets/walletConnectors/abcWallet/api/SolanaApi.ts
+import { PublicKey } from "@solana/web3.js";
+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"}`;
+    const network = getSolanaNetwork();
+    const response = await this.request(endpoint, {
+      method: "POST",
+      contentType: "json",
+      body: {
+        curve: "ed25519",
+        password: pin,
+        network
+      }
+    });
+    let result;
+    if (response.status === "success" && response.result) {
+      result = response.result;
+    } else if (response.encrypted_share && response.key_id) {
+      result = response;
+    } else {
+      throw createAbcError(
+        "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        `Failed to ${isRecover ? "recover" : "generate"} Solana wallet`,
+        response
+      );
+    }
+    let address;
+    try {
+      address = this.deriveAddressFromPublicKey(result.public_key);
+    } catch (_error) {
+      address = result.public_key.startsWith("0x") ? result.public_key.slice(2) : result.public_key;
+    }
+    return {
+      uid: result.uid || "",
+      sessionId: result.share_id,
+      shareId: result.share_id,
+      publicKey: result.public_key,
+      address,
+      keyId: result.key_id || result.share_id,
+      // API returns snake_case key_id
+      encryptedShare: result.encrypted_share || "",
+      // API returns snake_case encrypted_share
+      secretStore: result.secret_store || "",
+      // API returns snake_case secret_store
+      network
+      // Use network from request (already has correct value)
+    };
+  }
+  /**
+   * 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
+   * @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)
+   * Standard ABC WaaS pattern: server generates unsigned tx → client signs → server broadcasts
+   */
+  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
+    };
+  }
+  /**
+   * 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 || ""
+    };
+  }
+  /**
+   * Generic RPC call to Solana network
+   *
+   * @param params - RPC call parameters
+   * @returns RPC response
+   */
+  async rpcCall(params) {
+    const response = await this.request("/wapi/v2/solana/rpc/call", {
+      method: "POST",
+      contentType: "json",
+      body: {
+        network: params.network,
+        request: {
+          jsonrpc: "2.0",
+          id: 1,
+          method: params.method,
+          params: params.params
+        }
+      }
+    });
+    const responseData = response;
+    return responseData.data || response;
+  }
+  /**
+   * 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
+};