@talken/talkenkit 2.4.16 → 2.4.18

package/dist/providers/SignConfirmationProvider/SignConfirmationProvider.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Sign Confirmation Provider
+ *
+ * This component:
+ * - Auto-detects ABC Wallet connection
+ * - Registers request interceptor for sign/transaction confirmation
+ * - Shows appropriate confirmation modal based on request type
+ * - Uses RainbowKit theme automatically
+ */
+import React, { type ReactNode } from 'react';
+/**
+ * Hook to check if SignConfirmation modal is enabled.
+ * Returns `true` when `showSignConfirmation={true}` on TalkenKitProvider.
+ */
+export declare function useSignConfirmationEnabled(): boolean;
+export type { SignConfirmationRequest, RequestInterceptor } from './types';
+export type { ResolvedTransactionRequest, ApproveInfo, TransferInfo, SwapInfo, NftApprovalInfo, } from './types';
+interface SignConfirmationProviderProps {
+    children: ReactNode;
+    disabled?: boolean;
+}
+export declare function SignConfirmationProvider({ children, disabled, }: SignConfirmationProviderProps): React.JSX.Element;

package/dist/providers/SignConfirmationProvider/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SignConfirmationProvider Module
+ * Re-exports all public APIs
+ */
+export { SignConfirmationProvider, useSignConfirmationEnabled, } from './SignConfirmationProvider';
+export type { SignConfirmationRequest, RequestInterceptor, ResolvedTransactionRequest, ApproveInfo, TransferInfo, SwapInfo, NftApprovalInfo, RequestType, ParsedSignRequest, ParsedTypedDataRequest, ParsedTransactionParams, } from './types';

package/dist/providers/SignConfirmationProvider/requestParsers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Request Parsing Utilities
+ * Parse and decode various EVM request types for sign confirmation
+ */
+import type { ParsedSignRequest, ParsedTransactionParams, ParsedTypedDataRequest, RequestType } from './types';
+/**
+ * Determine request type from method
+ */
+export declare function getRequestType(method: string): RequestType;
+/**
+ * Parse personal_sign request params
+ * personal_sign: [message, address] - message can be hex or utf8
+ */
+export declare function parsePersonalSignParams(params: unknown[]): ParsedSignRequest;
+/**
+ * Parse eth_signTypedData_v4 request params
+ * eth_signTypedData_v4: [address, typedDataJson]
+ */
+export declare function parseTypedDataParams(params: unknown[]): ParsedTypedDataRequest | null;
+/**
+ * Parse eth_sendTransaction request params
+ * Extracts basic tx fields and decodes function data (sync, pure function)
+ */
+export declare function parseTransactionParams(params: unknown[]): ParsedTransactionParams | null;

package/dist/providers/SignConfirmationProvider/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * SignConfirmationProvider Types
+ * Extracted from SignConfirmationProvider.tsx for better modularity
+ */
+import type { FunctionType } from '../../components/ConfirmationModal/transactionUIRegistry';
+import type { GasOption } from '../../components/GasFeeModal';
+import type { NetworkConfig } from '../../config/networks';
+import type { FungibleToken, NonFungibleToken } from '../../types/token';
+import type { DecodedTransaction } from '../../utils/abi/abiDecoder';
+import type { ABCToken, SuggestedGasFees } from '../../wallets/walletConnectors/abcWallet/types';
+/**
+ * Sign confirmation request data
+ */
+export interface SignConfirmationRequest {
+    method: string;
+    params: unknown[];
+    chainId: number;
+    address: string;
+}
+/**
+ * Request interceptor function type
+ * Returns resolved transaction with user modifications if changed, undefined otherwise
+ */
+export type RequestInterceptor = (request: SignConfirmationRequest) => Promise<ResolvedTransactionRequest | undefined>;
+/**
+ * Request type classification
+ */
+export type RequestType = 'sign' | 'typedData' | 'transaction' | null;
+export interface ParsedSignRequest {
+    message: string;
+}
+export interface ParsedTypedDataRequest {
+    readableMessage: string;
+}
+/** Parsed transaction parameters (sync parsing result) */
+export interface ParsedTransactionParams {
+    to: string | null;
+    value: string;
+    data: string;
+    gasLimit?: string;
+    providedMaxFee?: string;
+    providedPriorityFee?: string;
+    decodedFunction?: DecodedTransaction;
+    functionType?: FunctionType;
+}
+/** ERC20 approve transaction info */
+export interface ApproveInfo {
+    spender: string;
+    amount: bigint;
+    balance?: bigint;
+    token: FungibleToken;
+}
+/** Token/Native transfer info */
+export interface TransferInfo {
+    from: string;
+    to: string;
+    token: FungibleToken | NonFungibleToken;
+    amount: string;
+    amountUsd?: string;
+}
+/** DEX swap transaction info */
+export interface SwapInfo {
+    tokenIn: FungibleToken;
+    tokenOut: FungibleToken;
+    amountIn: bigint;
+    amountOutMin: bigint;
+}
+/** NFT setApprovalForAll transaction info */
+export interface NftApprovalInfo {
+    operator: string;
+    approved: boolean;
+    nft?: NonFungibleToken;
+}
+/** Fully resolved transaction with decoded info and metadata */
+export interface ResolvedTransactionRequest {
+    to: string | null;
+    value: string;
+    data: string;
+    gasLimit?: string;
+    networkConfig?: NetworkConfig;
+    chainIconUrl?: string;
+    suggestedGasFees?: SuggestedGasFees;
+    gasFee?: GasOption;
+    functionType?: FunctionType;
+    decodedFunction?: DecodedTransaction;
+    approveInfo?: ApproveInfo;
+    transferInfo?: TransferInfo;
+    swapInfo?: SwapInfo;
+    nftApprovalInfo?: NftApprovalInfo;
+    nativeCoin?: ABCToken;
+}

package/dist/providers/SignConfirmationProvider/useApiClient.d.ts

@@ -0,0 +1,15 @@
+/**
+ * API Client Hook
+ * Provides API calls for gas fees, token metadata, and NFT metadata
+ */
+import type { ABCNFT, ABCToken, SuggestedGasFees } from '../../wallets/walletConnectors/abcWallet/types';
+/**
+ * Hook providing API client functions for transaction confirmation
+ */
+export declare function useApiClient(): {
+    fetchGasFees: (chainId: number) => Promise<SuggestedGasFees | null>;
+    fetchGasLimit: (chainId: number, to: string, value: string, data: string, fromAddress?: string) => Promise<string | null>;
+    fetchNativeTokenMetadata: (walletAddress: string, chainId: number) => Promise<ABCToken | null>;
+    fetchTokenMetadata: (tokenAddress: string, chainId: number) => Promise<ABCToken | null>;
+    fetchNFTMetadata: (contractAddress: string, walletAddress: string, chainId: number) => Promise<ABCNFT | null>;
+};

package/dist/providers/SignConfirmationProvider/useTransactionResolver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transaction Resolver Hook
+ * Resolves transaction parameters including gas estimation, function decoding,
+ * and metadata fetching for different transaction types
+ */
+import type { ParsedTransactionParams, ResolvedTransactionRequest, SignConfirmationRequest } from './types';
+/**
+ * Hook providing transaction resolution functions
+ */
+export declare function useTransactionResolver(): {
+    resolveTransaction: (request: SignConfirmationRequest) => Promise<ResolvedTransactionRequest | null>;
+    resolveGasAndMetadata: (parsed: ParsedTransactionParams, chainId: number, fromAddress?: string) => Promise<ResolvedTransactionRequest | null>;
+    resolveTransferInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+    resolveNativeTransferInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => void;
+    resolveApproveInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+    resolveSwapInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+    resolveNftApprovalInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+};

package/dist/services/AbcAuthService.d.ts

@@ -35,66 +35,72 @@ export interface LoginParams {
 }
 /**
  * Register new user with email, password, and OTP
- * Endpoint: POST /abc/adduser
- * Use case: Full email + password registration
+ * POST /wallet/auth { action: 'register' }
  */
-export declare function registerUser(params: RegisterUserParams, config?: {
+export declare function registerUser(params: RegisterUserParams, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Register SNS user with email and OTP only (no password)
- * Endpoint: POST /abc/snsAdduser
- * Use case: Google login or OTP-only registration
+ * POST /wallet/auth { action: 'register' }
  */
-export declare function registerSnsUser(params: RegisterSnsUserParams, config?: {
+export declare function registerSnsUser(params: RegisterSnsUserParams, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Set/Reset password for existing user
- * Endpoint: POST /abc/initpassword
- * Use case: Password setup for users registered via SNS (Code 619)
+ * POST /wallet/auth { action: 'password.reset' }
  */
-export declare function resetPassword(params: ResetPasswordParams, config?: {
+export declare function resetPassword(params: ResetPasswordParams, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Check if email already exists
- * Endpoint: GET /abc/emailCheck
+ * POST /wallet/auth { action: 'email.check' }
  */
-export declare function emailCheck(email: string, config?: {
+export declare function emailCheck(email: string, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Send OTP code to email
- * Endpoint: GET /member/mail-service/{email}/sendcode
+ * POST /wallet/auth { action: 'otp.send' }
  */
-export declare function sendOtpCode(email: string, config?: {
+export declare function sendOtpCode(email: string, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Verify OTP code for signup
- * Endpoint: POST /member/mail-service/{email}/verifycode
+ * POST /wallet/auth { action: 'otp.verify' }
  */
-export declare function verifyOtpCode(email: string, code: string, config?: {
+export declare function verifyOtpCode(email: string, code: string, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Login with email and password
- * Note: This uses Talken API server, requires fetch directly
+ * POST /wallet/auth { action: 'login', method: 'password' }
  */
-export declare function loginWithPassword(params: LoginParams, apiServer?: string): Promise<any>;
+export declare function loginWithPassword(params: LoginParams, _apiServer?: string): Promise<any>;
 /**
  * Google OAuth Login
- * Flow: Firebase popup → ID token → ABC WaaS snsLogin → Access token
- * Reference: tg-wallet-frontend LoginView/index.tsx:212-228
+ * Flow: Firebase popup → ID token → TalkenApiClient SNS login → Access token
  */
-export declare function googleLogin(config?: {
+export declare function googleLogin(_config?: {
+    waasUrl?: string;
+    environment?: string;
+    apiServer?: string;
+}): Promise<AbcSnsLoginResponse | null>;
+export declare function appleLogin(_config?: {
+    waasUrl?: string;
+    environment?: string;
+    apiServer?: string;
+}): Promise<AbcSnsLoginResponse | null>;
+export declare function kakaoLogin(_config?: {
     waasUrl?: string;
     environment?: string;
     apiServer?: string;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './token';
+export * from './solana';
+export * from './utils';

package/dist/types/token.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Base Token interface
+ * Common fields shared by FungibleToken and NonFungibleToken
+ */
+export interface Token {
+    chainId?: number;
+    network?: string;
+    platform?: string;
+    contractAddress?: string;
+    symbol?: string;
+    name?: string;
+    possibleSpam?: boolean;
+    enable?: boolean;
+    favorite?: boolean;
+    isCustom?: boolean;
+    mintAddress?: string;
+    associatedTokenAddress?: string;
+}
+/**
+ * Fungible Token model
+ * Compatible with ABC backend API and multi-chain support (EVM, Solana)
+ */
+export interface FungibleToken extends Token {
+    symbol: string;
+    decimals?: number;
+    icon?: string;
+    balance?: string;
+    usdRate?: number;
+    krwRate?: number;
+    isNative?: boolean;
+    website?: string;
+    description?: string;
+    totalSupply?: string;
+}
+/**
+ * Contract Type enum
+ * Supports ERC (Ethereum), KIP (Klaytn), and SPL (Solana) standards
+ */
+export declare const ContractType: {
+    readonly ERC20: "ERC20";
+    readonly ERC721: "ERC721";
+    readonly ERC1155: "ERC1155";
+    readonly KIP7: "KIP7";
+    readonly KIP17: "KIP17";
+    readonly KIP37: "KIP37";
+    readonly SPLToken: "SPLToken";
+};
+export type ContractType = (typeof ContractType)[keyof typeof ContractType];
+/**
+ * Parse contract type from string value
+ * @param value - Contract type string (e.g., 'ERC-721', 'erc721', 'KIP-7')
+ * @returns ContractType or null if not found
+ */
+export declare function contractTypeNameOf(value: string): ContractType | null;
+/**
+ * NFT Metadata (attributes, traits, etc.)
+ */
+export interface NFTMetadata {
+    attributes?: Array<{
+        trait_type?: string;
+        value?: string | number;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Non-Fungible Token model
+ * Compatible with ABC backend API response (ABCNFT → NonFungibleToken conversion)
+ */
+export interface NonFungibleToken extends Token {
+    contractAddress: string;
+    tokenId: string;
+    contractType?: ContractType;
+    collectionName?: string;
+    description?: string;
+    image?: string;
+    animationUrl?: string;
+    tokenUri?: string;
+    balance?: string;
+    isSbt?: boolean;
+    lastTransferAt?: string;
+    meta?: NFTMetadata;
+}

package/dist/utils/abi/abiDecoder.d.ts

@@ -0,0 +1,144 @@
+/**
+ * ABI Decoder
+ *
+ * Decodes transaction hex data using selector_index.json
+ * TypeScript port from Android ABIDecoder
+ */
+/**
+ * Input parameter definition
+ */
+export interface InputParam {
+    name: string;
+    type: string;
+    components?: InputParam[];
+    internalType?: string;
+}
+/**
+ * Function info from selector index
+ */
+export interface FunctionInfo {
+    name: string;
+    signature: string;
+    inputs: InputParam[];
+    sources: string[];
+}
+/**
+ * Metadata sources info
+ */
+export interface MetadataSources {
+    standards?: {
+        files: number;
+        functions: number;
+    };
+    implementations?: {
+        files: number;
+        functions: number;
+    };
+    sourcify?: {
+        contracts: number;
+        functions: number;
+    };
+    total?: number;
+}
+/**
+ * Selector index metadata
+ */
+export interface Metadata {
+    generatedAt: string;
+    totalFunctions: number;
+    sources?: MetadataSources;
+    collisions?: number;
+}
+/**
+ * Selector index structure
+ */
+export interface SelectorIndex {
+    functions: Record<string, FunctionInfo>;
+    metadata: Metadata;
+}
+/**
+ * Decoded transaction result
+ */
+export interface DecodedTransaction {
+    functionName: string;
+    signature: string;
+    selector: string;
+    parameters: Record<string, unknown>;
+    sources: string[];
+}
+/**
+ * ABI Decoder class
+ * Decodes EVM transaction calldata using a selector index
+ */
+export declare class ABIDecoder {
+    private selectorIndex;
+    constructor(selectorIndexJson: string | SelectorIndex);
+    /**
+     * Get function info by selector
+     */
+    getFunctionInfo(selector: string): FunctionInfo | null;
+    /**
+     * Get all known selectors
+     */
+    getKnownSelectors(): string[];
+    /**
+     * Get metadata
+     */
+    getMetadata(): Metadata;
+    /**
+     * Decode transaction hex data
+     *
+     * @param hexData Transaction input data (starts with 0x)
+     * @returns Decoded transaction information or null if unknown
+     */
+    decode(hexData: string): DecodedTransaction | null;
+    /**
+     * Decode ABI parameters
+     */
+    private decodeParameters;
+    /**
+     * Decode single value from data at given offset
+     */
+    private decodeValue;
+    /**
+     * Convert hex string to byte array
+     */
+    private hexToBytes;
+    /**
+     * Convert byte array to hex string
+     */
+    private bytesToHex;
+    /**
+     * Convert byte array to BigInt (unsigned)
+     */
+    private bytesToBigInt;
+}
+/**
+ * Create ABIDecoder from JSON string or object
+ */
+export declare function createABIDecoder(selectorIndex: string | SelectorIndex): ABIDecoder;
+/**
+ * Default selector index (common ERC20/721/1155 functions)
+ * This is a minimal set; for full coverage, load selector_index.json
+ */
+export declare const DEFAULT_SELECTORS: SelectorIndex;
+/**
+ * Usage example:
+ *
+ * // Using default selectors
+ * const decoder = new ABIDecoder(DEFAULT_SELECTORS);
+ *
+ * // Or load full selector index
+ * import selectorIndex from './selector_index.json';
+ * const fullDecoder = new ABIDecoder(selectorIndex);
+ *
+ * // Decode transaction
+ * const hexData = '0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f0bee40000000000000000000000000000000000000000000000000de0b6b3a7640000';
+ * const result = decoder.decode(hexData);
+ *
+ * result?.let {
+ *   console.log('Function:', result.functionName);       // 'transfer'
+ *   console.log('Signature:', result.signature);         // 'transfer(address,uint256)'
+ *   console.log('Parameters:', result.parameters);       // { to: '0x...', amount: '1000000000000000000' }
+ * }
+ */

package/dist/utils/apiClientFactory.d.ts

@@ -0,0 +1,21 @@
+/**
+ * API Client Factory Utilities
+ *
+ * Centralizes ABC WaaS API client creation to avoid code duplication.
+ */
+import { GasApi, WalletscanApi } from '../wallets/walletConnectors/abcWallet/api';
+import type { AbcWalletConfig } from '../wallets/walletConnectors/abcWallet/types';
+/**
+ * Get the ABC API configuration from environment variables
+ */
+export declare function getAbcApiConfig(): AbcWalletConfig;
+/**
+ * Create a WalletscanApi instance
+ * Use this for token metadata, NFT info, and wallet balance queries
+ */
+export declare function createWalletscanApi(): WalletscanApi;
+/**
+ * Create a GasApi instance
+ * Use this for gas fee estimation and suggestions
+ */
+export declare function createGasApi(): GasApi;

package/dist/utils/blockies.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Blockies - Ethereum address identicon generator
+ * Creates a data URL for a blockie image based on address
+ */
+/**
+ * Generate a blockies data URL for an Ethereum address
+ * @param address - Ethereum address (0x...)
+ * @param size - Size of the blockie (default: 8)
+ * @param scale - Scale factor (default: 4)
+ * @returns Data URL string for the blockie image
+ */
+export declare function createBlockiesDataUrl(address: string, size?: number, scale?: number): string;

package/dist/utils/tokenMapper.d.ts

@@ -0,0 +1,10 @@
+import type { FungibleToken, NonFungibleToken } from '../types/token';
+import type { ABCNFT, ABCToken } from '../wallets/walletConnectors/abcWallet/types';
+export declare function toFungibleToken(token: ABCToken): FungibleToken;
+export declare function toNonFungibleToken(nft: ABCNFT, contractAddress: string, tokenId?: string): NonFungibleToken;
+export declare function createFallbackFungibleToken(contractAddress: string): FungibleToken;
+export declare function createFallbackNonFungibleToken(contractAddress: string, tokenId?: string): NonFungibleToken;
+export declare function calculateUsdValue(amount: string, usdRate?: number): string | undefined;
+export declare function calculateKrwValue(amount: string, krwRate?: number): string | undefined;
+export declare function formatTokenAmount(rawAmount: bigint, decimals: number): string;
+export declare function convertIpfsUrl(uri?: string): string | undefined;

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

@@ -17,8 +17,10 @@ export declare class AbcWaasClient {
     private expiresAt;
     private isRefreshing;
     private refreshPromise;
-    private secure;
+    private readonly talkenAuthPath;
     constructor(config: AbcWalletConfig);
+    private getTalkenApiUrl;
+    private requestWalletAuth;
     /**
      * Load tokens from storage
      */
@@ -139,35 +141,31 @@ export declare class AbcWaasClient {
      */
     generateOrRecoverWallet(params: AbcWalletParams): Promise<AbcWalletResponse>;
     /**
-     * Sign EVM transaction (EIP-1559)
-     * Based on ABC WaaS official documentation
+     * @deprecated v2 signing removed. Use TalkenApiClient.evm.sendTransaction() instead.
      */
-    signTransaction(params: AbcSignParams): Promise<AbcSignatureResponse>;
+    signTransaction(_params: AbcSignParams): Promise<AbcSignatureResponse>;
     /**
-     * Sign message (Personal Sign - EIP-191)
-     * Based on tg-wallet-frontend reference implementation
+     * @deprecated v2 signing removed. Use TalkenApiClient.evm.personalSign() instead.
      */
-    signMessage(params: AbcSignMessageParams): Promise<AbcSignatureResponse>;
+    signMessage(_params: AbcSignMessageParams): Promise<AbcSignatureResponse>;
     /**
-     * Sign typed data (EIP-712)
-     * Reference: tg-wallet-frontend src/features/wallet/api/index.ts sign_typed_data()
+     * @deprecated v2 signing removed. Use TalkenApiClient.evm.signTypedData() instead.
      */
-    signTypedData(params: {
+    signTypedData(_params: {
         typedData: string;
         ciphertext?: string;
     }): Promise<{
         signature: string;
     }>;
     /**
-     * Send raw transaction
-     * Reference: tg-wallet-frontend src/features/wallet/api/index.ts sendRawTx()
+     * @deprecated v2 sendRawTransaction removed. Use TalkenApiClient.evm.sendRawTransaction() instead.
      */
-    sendRawTransaction(chainId: number, signedTransaction: string): Promise<{
+    sendRawTransaction(_chainId: number, _signedTransaction: string): Promise<{
         txHash: string;
     }>;
     /**
      * Estimate gas for EIP-1559 transaction
-     * Reference: ABC WaaS API docs - /wapi/v2/gas/estimate/eip1559
+     * Routes through TalkenApiClient (talken-api proxy)
      */
     estimateGas(params: {
         chainId: number;
@@ -177,8 +175,7 @@ export declare class AbcWaasClient {
         data?: string;
     }): Promise<string>;
     /**
-     * Get transaction count (nonce)
-     * Reference: ABC WaaS API - /wapi/v2/transactions/count
+     * Get transaction count (nonce) via TalkenApiClient
      */
     getTransactionCount(params: {
         chainId: number;
@@ -218,22 +215,20 @@ export declare class AbcWaasClient {
      * Get Solana address from Ed25519 public key
      * Reference: wallet/api/index.ts:74-82
      */
-    getSolanaAddress(publicKey: string, network: 'solana' | 'solana_devnet' | SolanaNetwork): Promise<string>;
+    getSolanaAddress(_publicKey: string, _network: 'solana' | 'solana_devnet' | SolanaNetwork): Promise<string>;
     /**
-     * Sign Solana transaction with Ed25519
-     * Reference: SigningService.ts:587-626, wallet/api/index.ts:114-122
+     * Sign Solana transaction with Ed25519 (via talken-api proxy)
      */
     signSolanaTransaction(params: AbcSignSolanaTransactionParams): Promise<AbcSignatureResponse>;
     /**
-     * Sign Solana message with Ed25519
-     * Reference: SigningService.ts:546-579
+     * Sign Solana message with Ed25519 (via talken-api proxy)
      */
     signSolanaMessage(params: AbcSignSolanaMessageParams): Promise<AbcSignatureResponse>;
     /**
-     * Send Solana transaction
-     * Reference: SigningService.ts:418, wallet/api/index.ts:124-132
+     * Send Solana transaction (via talken-api proxy)
+     * @deprecated Use TalkenApiClient.solana.transfer() for integrated flow
      */
-    sendSolanaTransaction(params: AbcSendSolanaTransactionParams): Promise<{
+    sendSolanaTransaction(_params: AbcSendSolanaTransactionParams): Promise<{
         txHash: string;
     }>;
 }

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

@@ -2,13 +2,11 @@
 import {
   AbcWaasClient,
   createAbcWaasClient
-} from "../chunk-Z34L5C76.js";
-import "../chunk-4PCVQBFZ.js";
-import "../chunk-NDYGTKP5.js";
-import "../chunk-A7FIBI6X.js";
-import "../chunk-5RSS3SRV.js";
-import "../chunk-RQIUWXDF.js";
-import "../chunk-VETRBBA2.js";
+} from "../chunk-BDM7TUVM.js";
+import "../chunk-7QHCSJDN.js";
+import "../chunk-6LH6ZME2.js";
+import "../chunk-D5EFTEOM.js";
+import "../chunk-DHHVIM22.js";
 export {
   AbcWaasClient,
   createAbcWaasClient