@t402/wdk 2.3.0 → 2.4.0

package/dist/cjs/types-V7c-qhn6.d.ts

@@ -0,0 +1,489 @@
+import { Address } from 'viem';
+
+/**
+ * Type definitions for T402 WDK integration
+ */
+
+/**
+ * EVM chain configuration
+ */
+interface EvmChainConfig {
+    /** RPC endpoint URL */
+    provider: string;
+    /** Chain ID */
+    chainId: number;
+    /** CAIP-2 network identifier */
+    network: string;
+}
+/**
+ * T402 WDK configuration options
+ */
+interface T402WDKConfig {
+    /** Ethereum mainnet configuration */
+    ethereum?: EvmChainConfig | string;
+    /** Arbitrum One configuration */
+    arbitrum?: EvmChainConfig | string;
+    /** Base mainnet configuration */
+    base?: EvmChainConfig | string;
+    /** Ink mainnet configuration */
+    ink?: EvmChainConfig | string;
+    /** Berachain mainnet configuration */
+    berachain?: EvmChainConfig | string;
+    /** Unichain mainnet configuration */
+    unichain?: EvmChainConfig | string;
+    /** Polygon mainnet configuration */
+    polygon?: EvmChainConfig | string;
+    /** Custom chains */
+    [key: string]: EvmChainConfig | string | undefined;
+}
+/**
+ * Normalized chain configuration
+ */
+interface NormalizedChainConfig {
+    provider: string;
+    chainId: number;
+    network: string;
+    name: string;
+}
+/**
+ * Token balance information
+ */
+interface TokenBalance {
+    /** Token contract address */
+    token: Address;
+    /** Token symbol */
+    symbol: string;
+    /** Balance in smallest units */
+    balance: bigint;
+    /** Formatted balance (human-readable) */
+    formatted: string;
+    /** Decimals */
+    decimals: number;
+}
+/**
+ * Chain balance information
+ */
+interface ChainBalance {
+    /** Chain name (e.g., "arbitrum") */
+    chain: string;
+    /** CAIP-2 network identifier */
+    network: string;
+    /** Native token balance */
+    native: bigint;
+    /** Token balances */
+    tokens: TokenBalance[];
+}
+/**
+ * Aggregated balance across all chains
+ */
+interface AggregatedBalance {
+    /** Total USDT0 balance across all chains */
+    totalUsdt0: bigint;
+    /** Total USDC balance across all chains */
+    totalUsdc: bigint;
+    /** Per-chain balances */
+    chains: ChainBalance[];
+}
+/**
+ * Bridge parameters for cross-chain transfers
+ */
+interface BridgeParams {
+    /** Source chain name */
+    fromChain: string;
+    /** Destination chain name */
+    toChain: string;
+    /** Amount to bridge in smallest units */
+    amount: bigint;
+    /** Recipient address (optional, defaults to same wallet on target chain) */
+    recipient?: Address;
+}
+/**
+ * Bridge result
+ */
+interface BridgeResult {
+    /** Transaction hash on source chain */
+    txHash: string;
+    /** Estimated time for bridge completion in seconds */
+    estimatedTime: number;
+}
+/**
+ * EIP-712 typed data domain
+ */
+interface TypedDataDomain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: Address;
+}
+/**
+ * EIP-712 typed data types
+ */
+type TypedDataTypes = Record<string, Array<{
+    name: string;
+    type: string;
+}>>;
+/**
+ * T402 Signer interface for WDK
+ * Compatible with @t402/core signer requirements
+ */
+interface T402WDKSigner {
+    /** Get wallet address */
+    readonly address: Address;
+    /** Sign EIP-712 typed data */
+    signTypedData(params: {
+        domain: TypedDataDomain;
+        types: TypedDataTypes;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<`0x${string}`>;
+    /** Sign a message */
+    signMessage?(message: string | Uint8Array): Promise<`0x${string}`>;
+    /** Get token balance */
+    getTokenBalance?(tokenAddress: Address): Promise<bigint>;
+}
+/**
+ * WDK Account interface (matches @tetherto/wdk account structure)
+ *
+ * This is the canonical definition used across all @t402/wdk-* packages.
+ * Implementors (Tether WDK) provide these methods; T402 code consumes them.
+ */
+interface WDKAccount {
+    /** Get the account's address */
+    getAddress(): Promise<string>;
+    /** Get the account's native balance */
+    getBalance(): Promise<bigint>;
+    /** Get the account's token balance */
+    getTokenBalance(tokenAddress: string): Promise<bigint>;
+    /** Sign a message */
+    signMessage(message: string): Promise<string>;
+    /** Sign typed data (EIP-712) */
+    signTypedData(params: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<string>;
+    /** Send a transaction */
+    sendTransaction(params: {
+        to: string;
+        value?: bigint;
+        data?: string;
+    }): Promise<string>;
+    /** Estimate gas for a transaction (optional — not all implementations support this) */
+    estimateGas?(params: {
+        to: string;
+        value?: bigint;
+        data?: string;
+    }): Promise<bigint>;
+}
+/**
+ * Alias for WDKAccount — preferred naming for use in @t402/wdk-* packages.
+ */
+type WdkAccount = WDKAccount;
+/**
+ * WDK instance interface (matches @tetherto/wdk structure)
+ */
+interface WDKInstance {
+    registerWallet<T>(name: string, manager: T, config: Record<string, unknown>): WDKInstance;
+    registerProtocol<T>(name: string, protocol: T): WDKInstance;
+    getAccount(chain: string, index: number): Promise<WDKAccount>;
+    executeProtocol(name: string, params: Record<string, unknown>): Promise<{
+        txHash: string;
+    }>;
+}
+/**
+ * WDK constructor type
+ */
+interface WDKConstructor {
+    new (seedPhrase: string): WDKInstance;
+    getRandomSeedPhrase(): string;
+}
+/**
+ * Balance cache configuration for T402WDK
+ */
+interface T402BalanceCacheConfig {
+    /** Whether caching is enabled (default: true) */
+    enabled?: boolean;
+    /** TTL for native balance in milliseconds (default: 15000 = 15 seconds) */
+    nativeBalanceTTL?: number;
+    /** TTL for token balance in milliseconds (default: 30000 = 30 seconds) */
+    tokenBalanceTTL?: number;
+    /** TTL for aggregated balances in milliseconds (default: 60000 = 60 seconds) */
+    aggregatedBalanceTTL?: number;
+    /** Maximum cache entries (default: 500) */
+    maxSize?: number;
+}
+/**
+ * Extended T402 WDK configuration with cache options
+ */
+interface T402WDKOptions {
+    /** Balance cache configuration */
+    cache?: T402BalanceCacheConfig;
+}
+/**
+ * Supported blockchain families
+ */
+type ChainFamily = 'evm' | 'svm' | 'ton' | 'tron';
+/**
+ * Solana chain configuration
+ */
+interface SvmChainConfig {
+    /** RPC endpoint URL */
+    rpcUrl: string;
+    /** Commitment level */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Network type */
+    network?: 'mainnet' | 'testnet' | 'devnet';
+}
+/**
+ * TON chain configuration
+ */
+interface TonChainConfig {
+    /** API endpoint URL */
+    endpoint: string;
+    /** Network type */
+    network?: 'mainnet' | 'testnet';
+    /** API key for TON Center */
+    apiKey?: string;
+}
+/**
+ * TRON chain configuration
+ */
+interface TronChainConfig {
+    /** Full host URL (e.g., https://api.trongrid.io) */
+    fullHost: string;
+    /** Network type */
+    network?: 'mainnet' | 'shasta' | 'nile';
+    /** API key for TronGrid */
+    apiKey?: string;
+}
+/**
+ * Multi-chain configuration
+ */
+interface MultiChainConfig {
+    /** EVM chains configuration */
+    evm?: Record<string, EvmChainConfig | string>;
+    /** Solana configuration */
+    svm?: SvmChainConfig;
+    /** TON configuration */
+    ton?: TonChainConfig;
+    /** TRON configuration */
+    tron?: TronChainConfig;
+}
+/**
+ * WDK wallet modules registry
+ * All modules are optional - only register what you need
+ */
+interface WDKWalletModules {
+    /** EVM wallet manager (@tetherto/wdk-wallet-evm) */
+    evm?: unknown;
+    /** EVM ERC-4337 wallet manager (@tetherto/wdk-wallet-evm-erc4337) */
+    evmErc4337?: unknown;
+    /** Solana wallet manager (@tetherto/wdk-wallet-solana) */
+    solana?: unknown;
+    /** TON wallet manager (@tetherto/wdk-wallet-ton) */
+    ton?: unknown;
+    /** TON gasless wallet manager (@tetherto/wdk-wallet-ton-gasless) */
+    tonGasless?: unknown;
+    /** TRON wallet manager (@tetherto/wdk-wallet-tron) */
+    tron?: unknown;
+    /** Bitcoin wallet manager (@tetherto/wdk-wallet-btc) */
+    btc?: unknown;
+}
+/**
+ * WDK protocol modules registry
+ * All modules are optional - only register what you need
+ */
+interface WDKProtocolModules {
+    /** USDT0 bridge for EVM (@tetherto/wdk-protocol-bridge-usdt0-evm) */
+    bridgeUsdt0Evm?: unknown;
+    /** USDT0 bridge for TON (@tetherto/wdk-protocol-bridge-usdt0-ton) */
+    bridgeUsdt0Ton?: unknown;
+    /** Velora swap for EVM (@tetherto/wdk-protocol-swap-velora-evm) */
+    swapVeloraEvm?: unknown;
+    /** Aave lending for EVM (@tetherto/wdk-protocol-lending-aave-evm) */
+    lendingAaveEvm?: unknown;
+}
+/**
+ * Unified WDK modules registration
+ */
+interface WDKModulesConfig {
+    /** Wallet modules */
+    wallets?: WDKWalletModules;
+    /** Protocol modules */
+    protocols?: WDKProtocolModules;
+}
+/**
+ * WDK TON account interface (compatible with @tetherto/wdk-wallet-ton)
+ */
+interface WDKTonAccount {
+    /** Get wallet address */
+    getAddress(): Promise<string>;
+    /** Get TON balance */
+    getBalance(): Promise<bigint>;
+    /** Get Jetton balance */
+    getJettonBalance(jettonMaster: string): Promise<bigint>;
+    /** Sign a message */
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    /** Send TON transaction */
+    sendTransaction(params: {
+        to: string;
+        value: bigint;
+        body?: string;
+        bounce?: boolean;
+    }): Promise<string>;
+    /** Get current sequence number */
+    getSeqno(): Promise<number>;
+    /** Transfer Jettons */
+    transferJetton?(params: {
+        jettonMaster: string;
+        to: string;
+        amount: bigint;
+        forwardPayload?: string;
+    }): Promise<string>;
+}
+/**
+ * WDK Solana account interface (compatible with @tetherto/wdk-wallet-solana)
+ */
+interface WDKSolanaAccount {
+    /** Get wallet address (base58) */
+    getAddress(): Promise<string>;
+    /** Get SOL balance */
+    getBalance(): Promise<bigint>;
+    /** Get SPL token balance */
+    getTokenBalance(mint: string): Promise<bigint>;
+    /** Sign a message */
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    /** Sign a transaction */
+    signTransaction(transaction: Uint8Array): Promise<Uint8Array>;
+    /** Send SOL */
+    sendTransaction(params: {
+        recipient: string;
+        value: bigint;
+    }): Promise<string>;
+    /** Transfer SPL token */
+    transfer(params: {
+        token: string;
+        recipient: string;
+        amount: bigint;
+    }): Promise<string>;
+}
+/**
+ * WDK TRON account interface (compatible with @tetherto/wdk-wallet-tron)
+ */
+interface WDKTronAccount {
+    /** Get wallet address (base58) */
+    getAddress(): Promise<string>;
+    /** Get TRX balance */
+    getBalance(): Promise<bigint>;
+    /** Get TRC20 token balance */
+    getTrc20Balance(contractAddress: string): Promise<bigint>;
+    /** Sign a transaction */
+    signTransaction(transaction: unknown): Promise<unknown>;
+    /** Send signed transaction */
+    sendTransaction(signedTx: unknown): Promise<string>;
+    /** Transfer TRC20 token */
+    transferTrc20?(params: {
+        contractAddress: string;
+        to: string;
+        amount: bigint;
+    }): Promise<string>;
+}
+/**
+ * Extended WDK instance interface with multi-chain support
+ */
+interface WDKInstanceMultiChain extends WDKInstance {
+    /** Get TON account */
+    getTonAccount?(index: number): Promise<WDKTonAccount>;
+    /** Get Solana account */
+    getSolanaAccount?(index: number): Promise<WDKSolanaAccount>;
+    /** Get TRON account */
+    getTronAccount?(index: number): Promise<WDKTronAccount>;
+}
+/**
+ * Configuration for T402WDK.create() factory method
+ */
+interface T402WDKCreateConfig {
+    /** BIP-39 mnemonic seed phrase */
+    seedPhrase: string;
+    /** Chain name → RPC URL mapping for EVM chains */
+    chains: Record<string, string>;
+    /** WDK modules to register */
+    modules: WDKModulesConfig;
+    /** Additional options */
+    options?: T402WDKOptions;
+}
+/**
+ * A signer entry for use with T402 HTTP clients
+ */
+interface SignerEntry {
+    /** Payment scheme (e.g., "exact") */
+    scheme: string;
+    /** CAIP-2 network identifier (e.g., "eip155:42161") */
+    network: string;
+    /** The signer instance */
+    signer: unknown;
+    /** Chain family (evm, ton, svm, tron) */
+    family: ChainFamily;
+}
+/**
+ * Options for getAllSigners()
+ */
+interface GetAllSignersOptions {
+    /** HD wallet account index (default: 0) */
+    accountIndex?: number;
+    /** Filter by payment schemes (default: ["exact"]) */
+    schemes?: string[];
+    /** Include non-EVM chain signers (default: true) */
+    includeNonEvm?: boolean;
+}
+/**
+ * Options for T402WDK.fromWDK()
+ */
+interface FromWDKOptions {
+    /** HD wallet account index for auto-discovery (default: 0) */
+    defaultAccountIndex?: number;
+}
+/**
+ * Swap quote result
+ */
+interface SwapQuote {
+    /** Input token address */
+    inputToken: string;
+    /** Output token address */
+    outputToken: string;
+    /** Input amount in smallest units */
+    inputAmount: bigint;
+    /** Expected output amount in smallest units */
+    outputAmount: bigint;
+    /** Price impact percentage */
+    priceImpact: number;
+    /** Swap route (token addresses) */
+    route: string[];
+}
+/**
+ * Swap execution result
+ */
+interface SwapResult {
+    /** Transaction hash */
+    txHash: string;
+    /** Actual input amount */
+    inputAmount: bigint;
+    /** Actual output amount */
+    outputAmount: bigint;
+}
+/**
+ * Parameters for swap operations
+ */
+interface SwapParams {
+    /** Chain name (e.g., "ethereum", "arbitrum") */
+    chain: string;
+    /** Input token address */
+    fromToken: string;
+    /** Amount to swap in smallest units */
+    amount: bigint;
+    /** Maximum slippage tolerance (0-1, default: 0.005 = 0.5%) */
+    maxSlippage?: number;
+}
+
+export type { AggregatedBalance as A, BridgeParams as B, ChainFamily as C, EvmChainConfig as E, FromWDKOptions as F, GetAllSignersOptions as G, MultiChainConfig as M, NormalizedChainConfig as N, SignerEntry as S, T402WDKCreateConfig as T, WDKSolanaAccount as W, WDKTonAccount as a, WDKTronAccount as b, WDKInstance as c, WDKConstructor as d, WDKModulesConfig as e, WDKWalletModules as f, WDKProtocolModules as g, T402WDKConfig as h, T402WDKOptions as i, ChainBalance as j, BridgeResult as k, SwapQuote as l, SwapParams as m, SwapResult as n, T402BalanceCacheConfig as o, TokenBalance as p, TypedDataDomain as q, TypedDataTypes as r, T402WDKSigner as s, WDKAccount as t, WdkAccount as u, SvmChainConfig as v, TonChainConfig as w, TronChainConfig as x, WDKInstanceMultiChain as y };

package/dist/esm/adapters/index.d.mts

@@ -0,0 +1,5 @@
+export { WDKTonSignerAdapter, createWDKTonSigner } from './ton-adapter.mjs';
+export { WDKSvmSignerAdapter, createWDKSvmSigner } from './svm-adapter.mjs';
+export { WDKTronSignerAdapter, createWDKTronSigner } from './tron-adapter.mjs';
+import '../types-V7c-qhn6.mjs';
+import 'viem';

package/dist/esm/adapters/index.mjs

@@ -0,0 +1,21 @@
+import {
+  WDKSvmSignerAdapter,
+  createWDKSvmSigner
+} from "../chunk-MCFHZSF7.mjs";
+import {
+  WDKTonSignerAdapter,
+  createWDKTonSigner
+} from "../chunk-YWBJJV5M.mjs";
+import {
+  WDKTronSignerAdapter,
+  createWDKTronSigner
+} from "../chunk-HB2DGKQ3.mjs";
+export {
+  WDKSvmSignerAdapter,
+  WDKTonSignerAdapter,
+  WDKTronSignerAdapter,
+  createWDKSvmSigner,
+  createWDKTonSigner,
+  createWDKTronSigner
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/adapters/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/adapters/svm-adapter.d.mts

@@ -0,0 +1,125 @@
+import { W as WDKSolanaAccount } from '../types-V7c-qhn6.mjs';
+import 'viem';
+
+/**
+ * Solana (SVM) Signer Adapter for WDK
+ *
+ * Wraps a Tether WDK Solana account to implement T402's ClientSvmSigner interface.
+ * ClientSvmSigner is just TransactionSigner from @solana/kit.
+ */
+
+/**
+ * Address type from @solana/kit (base58 string)
+ * We use a branded type for compatibility
+ */
+type SolanaAddress = string & {
+    readonly __brand?: unique symbol;
+};
+/**
+ * TransactionSigner interface matching @solana/kit
+ * This is what T402's ClientSvmSigner expects
+ */
+interface TransactionSigner {
+    readonly address: SolanaAddress;
+    signTransactions<T extends {
+        messageBytes: Uint8Array;
+        signatures: Record<string, unknown>;
+    }>(transactions: readonly T[]): Promise<readonly Record<string, Uint8Array>[]>;
+}
+/**
+ * WDKSvmSignerAdapter - Adapts a WDK Solana account to T402's ClientSvmSigner
+ *
+ * ClientSvmSigner is TransactionSigner from @solana/kit which requires:
+ * - address: The public key as Address type
+ * - signTransactions: Sign multiple transactions, returning signature dictionaries
+ *
+ * @example
+ * ```typescript
+ * const adapter = await createWDKSvmSigner(wdkSolanaAccount);
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'solana:mainnet', signer: adapter }]
+ * });
+ * ```
+ */
+declare class WDKSvmSignerAdapter implements TransactionSigner {
+    private _account;
+    private _address;
+    private _initialized;
+    constructor(account: WDKSolanaAccount);
+    /**
+     * Get the wallet address (base58)
+     * @throws Error if not initialized
+     */
+    get address(): SolanaAddress;
+    /**
+     * Check if the adapter is initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Initialize the adapter by fetching the address
+     * Must be called before using the signer
+     */
+    initialize(): Promise<void>;
+    /**
+     * Sign transactions with this signer
+     *
+     * This method signs the message bytes of each transaction and returns
+     * signature dictionaries mapping address to signature.
+     *
+     * @param transactions - Array of transactions to sign
+     * @returns Array of signature dictionaries
+     */
+    signTransactions<T extends {
+        messageBytes: Uint8Array;
+        signatures: Record<string, unknown>;
+    }>(transactions: readonly T[]): Promise<readonly Record<string, Uint8Array>[]>;
+    /**
+     * Sign a single message (utility method)
+     * @param message - Message bytes to sign
+     * @returns Signature bytes
+     */
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get SOL balance in lamports
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get SPL token balance
+     * @param mint - Token mint address
+     */
+    getTokenBalance(mint: string): Promise<bigint>;
+    /**
+     * Transfer SPL tokens
+     * @param params - Transfer parameters
+     * @returns Transaction signature
+     */
+    transfer(params: {
+        token: string;
+        recipient: string;
+        amount: bigint;
+    }): Promise<string>;
+}
+/**
+ * Create an initialized WDK Solana signer
+ *
+ * @param account - WDK Solana account from @tetherto/wdk-wallet-solana
+ * @returns Initialized TransactionSigner (ClientSvmSigner)
+ *
+ * @example
+ * ```typescript
+ * import { T402WDK } from '@t402/wdk';
+ *
+ * const wallet = new T402WDK(seedPhrase, config);
+ * const svmSigner = await wallet.getSvmSigner();
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'solana:mainnet', signer: svmSigner }]
+ * });
+ * ```
+ */
+declare function createWDKSvmSigner(account: WDKSolanaAccount): Promise<WDKSvmSignerAdapter>;
+
+export { type SolanaAddress, type TransactionSigner, WDKSvmSignerAdapter, createWDKSvmSigner };

package/dist/esm/adapters/svm-adapter.mjs

@@ -0,0 +1,9 @@
+import {
+  WDKSvmSignerAdapter,
+  createWDKSvmSigner
+} from "../chunk-MCFHZSF7.mjs";
+export {
+  WDKSvmSignerAdapter,
+  createWDKSvmSigner
+};
+//# sourceMappingURL=svm-adapter.mjs.map

package/dist/esm/adapters/svm-adapter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}