@t402/wdk 2.4.0 → 2.6.0

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

@@ -1,5 +1,202 @@
 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 '../types-BwK8Xgvg.mjs';
 import 'viem';
+
+/**
+ * Spark (Bitcoin L2) Signer Adapter for WDK
+ *
+ * Wraps a Spark wallet account to implement T402's payment signing interface.
+ * Spark is a Bitcoin L2 built on the Spark SDK (@buildonspark/spark-sdk).
+ */
+/**
+ * SparkWalletAccount interface (matches @buildonspark/spark-sdk)
+ */
+interface SparkWalletAccount {
+    getAddress(): Promise<string>;
+    getBalance(): Promise<bigint>;
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+    }): Promise<{
+        hash: string;
+    }>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+}
+/**
+ * WDKSparkSignerAdapter - Adapts a Spark wallet account for T402 payments
+ *
+ * @example
+ * ```typescript
+ * const adapter = await createWDKSparkSigner(sparkAccount);
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'spark:mainnet', signer: adapter }]
+ * });
+ * ```
+ */
+declare class WDKSparkSignerAdapter {
+    private _account;
+    private _address;
+    private _initialized;
+    constructor(account: SparkWalletAccount);
+    /**
+     * Get the wallet address
+     * @throws Error if not initialized
+     */
+    get address(): string;
+    /**
+     * 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 a message using the Spark wallet
+     * @param message - Message to sign (string or bytes)
+     * @returns Signature string
+     */
+    signMessage(message: string | Uint8Array): Promise<string>;
+    /**
+     * Get the wallet balance in satoshis
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Send a transaction via the Spark network
+     * @param params - Transaction parameters
+     * @returns Transaction result with hash
+     */
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+    }): Promise<{
+        hash: string;
+    }>;
+}
+/**
+ * Create an initialized WDK Spark signer
+ *
+ * @param account - Spark wallet account from @buildonspark/spark-sdk
+ * @returns Initialized WDKSparkSignerAdapter
+ *
+ * @example
+ * ```typescript
+ * import { T402WDK } from '@t402/wdk';
+ *
+ * const wallet = new T402WDK(seedPhrase, config);
+ * const sparkSigner = await wallet.getSparkSigner();
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'spark:mainnet', signer: sparkSigner }]
+ * });
+ * ```
+ */
+declare function createWDKSparkSigner(account: SparkWalletAccount): Promise<WDKSparkSignerAdapter>;
+
+/**
+ * Bitcoin (BTC) On-Chain Signer Adapter for WDK
+ *
+ * Wraps a Tether WDK Bitcoin account to implement T402's payment signing interface.
+ * This allows WDK-managed Bitcoin wallets to be used for T402 payments.
+ */
+/**
+ * WDKBtcAccount interface (matches @tetherto/wdk-wallet-btc)
+ */
+interface WDKBtcAccount {
+    getAddress(): Promise<string>;
+    getBalance(): Promise<bigint>;
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+        fee?: bigint;
+    }): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    signPsbt(psbt: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * WDKBtcSignerAdapter - Adapts a WDK Bitcoin account for T402 payments
+ *
+ * @example
+ * ```typescript
+ * const adapter = await createWDKBtcSigner(wdkBtcAccount);
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'bip122:000000000019d6689c085ae165831e93', signer: adapter }]
+ * });
+ * ```
+ */
+declare class WDKBtcSignerAdapter {
+    private _account;
+    private _address;
+    private _initialized;
+    constructor(account: WDKBtcAccount);
+    /**
+     * Get the wallet address
+     * @throws Error if not initialized
+     */
+    get address(): string;
+    /**
+     * 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 a message using the Bitcoin wallet
+     * @param message - Message string to sign
+     * @returns Signature string
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Sign a Partially Signed Bitcoin Transaction (PSBT)
+     * @param psbt - PSBT bytes to sign
+     * @returns Signed PSBT bytes
+     */
+    signPsbt(psbt: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the wallet balance in satoshis
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Send a Bitcoin transaction
+     * @param params - Transaction parameters
+     * @returns Transaction hash
+     */
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+        fee?: bigint;
+    }): Promise<string>;
+}
+/**
+ * Create an initialized WDK Bitcoin signer
+ *
+ * @param account - WDK Bitcoin account from @tetherto/wdk-wallet-btc
+ * @returns Initialized WDKBtcSignerAdapter
+ *
+ * @example
+ * ```typescript
+ * import { T402WDK } from '@t402/wdk';
+ *
+ * const wallet = new T402WDK(seedPhrase, config);
+ * const btcSigner = await wallet.getBtcSigner();
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'bip122:000000000019d6689c085ae165831e93', signer: btcSigner }]
+ * });
+ * ```
+ */
+declare function createWDKBtcSigner(account: WDKBtcAccount): Promise<WDKBtcSignerAdapter>;
+
+export { WDKBtcSignerAdapter, WDKSparkSignerAdapter, createWDKBtcSigner, createWDKSparkSigner };

package/dist/esm/adapters/index.mjs

@@ -1,19 +1,30 @@
+import {
+  WDKBtcSignerAdapter,
+  WDKSparkSignerAdapter,
+  createWDKBtcSigner,
+  createWDKSparkSigner
+} from "../chunk-7CG77QAN.mjs";
 import {
   WDKSvmSignerAdapter,
   createWDKSvmSigner
-} from "../chunk-MCFHZSF7.mjs";
+} from "../chunk-2KWVW77U.mjs";
 import {
   WDKTonSignerAdapter,
   createWDKTonSigner
-} from "../chunk-YWBJJV5M.mjs";
+} from "../chunk-KWX6CJIH.mjs";
 import {
   WDKTronSignerAdapter,
   createWDKTronSigner
-} from "../chunk-HB2DGKQ3.mjs";
+} from "../chunk-QZKUU2O6.mjs";
+import "../chunk-BJTO5JO5.mjs";
 export {
+  WDKBtcSignerAdapter,
+  WDKSparkSignerAdapter,
   WDKSvmSignerAdapter,
   WDKTonSignerAdapter,
   WDKTronSignerAdapter,
+  createWDKBtcSigner,
+  createWDKSparkSigner,
   createWDKSvmSigner,
   createWDKTonSigner,
   createWDKTronSigner

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

@@ -1,4 +1,4 @@
-import { W as WDKSolanaAccount } from '../types-V7c-qhn6.mjs';
+import { W as WDKSolanaAccount } from '../types-BwK8Xgvg.mjs';
 import 'viem';
 
 /**
@@ -6,6 +6,12 @@ import 'viem';
  *
  * Wraps a Tether WDK Solana account to implement T402's ClientSvmSigner interface.
  * ClientSvmSigner is just TransactionSigner from @solana/kit.
+ *
+ * Includes support for:
+ * - Versioned transactions (v0) with address lookup tables
+ * - Priority fees via ComputeBudget program
+ * - Token-2022 program detection and transfer fee queries
+ * - Associated Token Account resolution
  */
 
 /**
@@ -101,6 +107,144 @@ declare class WDKSvmSignerAdapter implements TransactionSigner {
         amount: bigint;
     }): Promise<string>;
 }
+/**
+ * Serialized instruction for building transactions
+ */
+interface SerializedInstruction {
+    programId: string;
+    keys: Array<{
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>;
+    data: Uint8Array;
+}
+/**
+ * Parameters for building a versioned (v0) transaction
+ */
+interface BuildVersionedTransactionParams {
+    instructions: SerializedInstruction[];
+    addressLookupTableAccounts?: Array<{
+        key: string;
+        addresses: string[];
+    }>;
+    priorityFee?: {
+        microLamports: number;
+        computeUnits?: number;
+    };
+}
+/**
+ * Parameters for a transfer with priority fee
+ */
+interface TransferWithPriorityFeeParams {
+    token: string;
+    recipient: string;
+    amount: bigint;
+    priorityFeeMicroLamports?: number;
+    createATA?: boolean;
+}
+/**
+ * Result of querying recent priority fees
+ */
+interface PriorityFeeEstimate {
+    low: number;
+    medium: number;
+    high: number;
+}
+/**
+ * ATA resolution result
+ */
+interface ATAResolution {
+    address: string;
+    exists: boolean;
+    createInstruction?: SerializedInstruction;
+}
+/**
+ * Token program type
+ */
+type TokenProgramType = 'Token' | 'Token-2022';
+/**
+ * Transfer fee information for Token-2022 tokens
+ */
+interface TransferFeeInfo {
+    fee: bigint;
+    netAmount: bigint;
+    transferFeeBasisPoints: number;
+    maximumFee: bigint;
+}
+/**
+ * Build a versioned (v0) transaction with optional priority fee.
+ *
+ * This constructs a v0 transaction message that supports address lookup tables
+ * for compact encoding and ComputeBudget instructions for priority fees.
+ *
+ * @param adapter - The initialized SVM signer adapter
+ * @param params - Transaction build parameters
+ * @returns Serialized v0 transaction message bytes
+ */
+declare function buildVersionedTransaction(adapter: WDKSvmSignerAdapter, params: BuildVersionedTransactionParams): Uint8Array;
+/**
+ * Transfer SPL tokens with an attached priority fee.
+ *
+ * Wraps a standard SPL token transfer with ComputeBudget instructions
+ * to ensure timely inclusion during congested periods.
+ *
+ * @param adapter - The initialized SVM signer adapter
+ * @param params - Transfer parameters
+ * @returns Transaction signature
+ */
+declare function transferWithPriorityFee(adapter: WDKSvmSignerAdapter, params: TransferWithPriorityFeeParams): Promise<string>;
+/**
+ * Get recommended priority fees from recent blocks.
+ *
+ * Returns low/medium/high estimates in micro-lamports per compute unit.
+ * Caller should use these as hints for `priorityFee.microLamports`.
+ *
+ * @param rpcUrl - Solana RPC endpoint URL
+ * @returns Priority fee estimates
+ */
+declare function getRecentPriorityFees(rpcUrl: string): Promise<PriorityFeeEstimate>;
+/**
+ * Resolve the Associated Token Account (ATA) for an owner/mint pair.
+ *
+ * If the ATA does not exist, returns a creation instruction that can be
+ * prepended to the transaction.
+ *
+ * @param rpcUrl - Solana RPC endpoint URL
+ * @param owner - Owner public key (base58)
+ * @param mint - Token mint address (base58)
+ * @returns ATA resolution result
+ */
+declare function resolveATA(rpcUrl: string, owner: string, mint: string): Promise<ATAResolution>;
+/**
+ * Determine whether a token mint uses the standard Token program or Token-2022.
+ *
+ * @param rpcUrl - Solana RPC endpoint URL
+ * @param mint - Token mint address (base58)
+ * @returns Token program type
+ */
+declare function getTokenProgram(rpcUrl: string, mint: string): Promise<TokenProgramType>;
+/**
+ * Get the transfer fee for a Token-2022 mint.
+ *
+ * Queries the mint's transfer fee extension data. Returns zero fee
+ * if the mint is a standard Token program mint or has no transfer fee extension.
+ *
+ * @param rpcUrl - Solana RPC endpoint URL
+ * @param mint - Token mint address (base58)
+ * @param amount - Transfer amount in smallest units
+ * @returns Transfer fee info
+ */
+declare function getTransferFee(rpcUrl: string, mint: string, amount: bigint): Promise<TransferFeeInfo>;
+/**
+ * Derive an Associated Token Account address deterministically.
+ * Uses the standard PDA derivation: [owner, TOKEN_PROGRAM_ID, mint] seeded
+ * under the Associated Token Program.
+ *
+ * This is a simplified derivation returning a deterministic string.
+ * For production use, integrate with @solana/kit's findProgramAddress.
+ */
+declare function deriveATAAddress(owner: string, mint: string): string;
 /**
  * Create an initialized WDK Solana signer
  *
@@ -122,4 +266,4 @@ declare class WDKSvmSignerAdapter implements TransactionSigner {
  */
 declare function createWDKSvmSigner(account: WDKSolanaAccount): Promise<WDKSvmSignerAdapter>;
 
-export { type SolanaAddress, type TransactionSigner, WDKSvmSignerAdapter, createWDKSvmSigner };
+export { type ATAResolution, type BuildVersionedTransactionParams, type PriorityFeeEstimate, type SerializedInstruction, type SolanaAddress, type TokenProgramType, type TransactionSigner, type TransferFeeInfo, type TransferWithPriorityFeeParams, WDKSvmSignerAdapter, buildVersionedTransaction, createWDKSvmSigner, deriveATAAddress, getRecentPriorityFees, getTokenProgram, getTransferFee, resolveATA, transferWithPriorityFee };

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

@@ -1,9 +1,24 @@
 import {
   WDKSvmSignerAdapter,
-  createWDKSvmSigner
-} from "../chunk-MCFHZSF7.mjs";
+  buildVersionedTransaction,
+  createWDKSvmSigner,
+  deriveATAAddress,
+  getRecentPriorityFees,
+  getTokenProgram,
+  getTransferFee,
+  resolveATA,
+  transferWithPriorityFee
+} from "../chunk-2KWVW77U.mjs";
+import "../chunk-BJTO5JO5.mjs";
 export {
   WDKSvmSignerAdapter,
-  createWDKSvmSigner
+  buildVersionedTransaction,
+  createWDKSvmSigner,
+  deriveATAAddress,
+  getRecentPriorityFees,
+  getTokenProgram,
+  getTransferFee,
+  resolveATA,
+  transferWithPriorityFee
 };
 //# sourceMappingURL=svm-adapter.mjs.map

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

@@ -1,4 +1,4 @@
-import { a as WDKTonAccount } from '../types-V7c-qhn6.mjs';
+import { a as WDKTonAccount } from '../types-BwK8Xgvg.mjs';
 import 'viem';
 
 /**
@@ -115,6 +115,61 @@ declare class WDKTonSignerAdapter implements ClientTonSigner {
      */
     getWDKAccount(): WDKTonAccount;
 }
+/**
+ * Parameters for waiting on a Jetton transfer completion
+ */
+interface WaitForJettonTransferParams {
+    /** External message hash (from the sent transaction) */
+    externalMessageHash: string;
+    /** Jetton master contract address */
+    jettonMaster: string;
+    /** Expected recipient address */
+    expectedRecipient: string;
+    /** Expected amount in smallest units */
+    expectedAmount: bigint;
+    /** Timeout in milliseconds (default: 120000 = 2 min) */
+    timeoutMs?: number;
+    /** Poll interval in milliseconds (default: 3000 = 3s) */
+    pollIntervalMs?: number;
+    /** Callback on status change */
+    onStatusChange?: (status: JettonTransferStatus) => void;
+}
+/**
+ * Jetton transfer status
+ */
+type JettonTransferStatus = 'pending' | 'confirming' | 'completed' | 'failed' | 'timeout';
+/**
+ * Result of waiting for a Jetton transfer
+ */
+interface JettonTransferResult {
+    success: boolean;
+    status: JettonTransferStatus;
+    transactionHash?: string;
+    error?: string;
+}
+/**
+ * Wait for a Jetton transfer to complete by polling the TON API.
+ *
+ * Follows the internal message chain from the external message through
+ * the Jetton wallet to the recipient.
+ *
+ * @param apiEndpoint - TON API endpoint (e.g., https://toncenter.com/api/v2)
+ * @param params - Transfer parameters to verify
+ * @returns Transfer result
+ */
+declare function waitForJettonTransfer(apiEndpoint: string, params: WaitForJettonTransferParams): Promise<JettonTransferResult>;
+/**
+ * Resolve a Jetton wallet address for a given owner and Jetton master.
+ *
+ * Calls the Jetton master's `get_wallet_address` GET method to
+ * deterministically derive the Jetton wallet address.
+ *
+ * @param apiEndpoint - TON API endpoint
+ * @param ownerAddress - Owner's wallet address
+ * @param jettonMaster - Jetton master contract address
+ * @returns Jetton wallet address string
+ */
+declare function getJettonWalletAddress(apiEndpoint: string, ownerAddress: string, jettonMaster: string): Promise<string>;
 /**
  * Create an initialized WDK TON signer
  *
@@ -136,4 +191,4 @@ declare class WDKTonSignerAdapter implements ClientTonSigner {
  */
 declare function createWDKTonSigner(account: WDKTonAccount): Promise<WDKTonSignerAdapter>;
 
-export { type ClientTonSigner, type SignMessageParams, type TonAddress, type TonCell, WDKTonSignerAdapter, createWDKTonSigner };
+export { type ClientTonSigner, type JettonTransferResult, type JettonTransferStatus, type SignMessageParams, type TonAddress, type TonCell, WDKTonSignerAdapter, type WaitForJettonTransferParams, createWDKTonSigner, getJettonWalletAddress, waitForJettonTransfer };

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

@@ -1,9 +1,14 @@
 import {
   WDKTonSignerAdapter,
-  createWDKTonSigner
-} from "../chunk-YWBJJV5M.mjs";
+  createWDKTonSigner,
+  getJettonWalletAddress,
+  waitForJettonTransfer
+} from "../chunk-KWX6CJIH.mjs";
+import "../chunk-BJTO5JO5.mjs";
 export {
   WDKTonSignerAdapter,
-  createWDKTonSigner
+  createWDKTonSigner,
+  getJettonWalletAddress,
+  waitForJettonTransfer
 };
 //# sourceMappingURL=ton-adapter.mjs.map

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

@@ -1,4 +1,4 @@
-import { b as WDKTronAccount } from '../types-V7c-qhn6.mjs';
+import { b as WDKTronAccount } from '../types-BwK8Xgvg.mjs';
 import 'viem';
 
 /**
@@ -6,6 +6,11 @@ import 'viem';
  *
  * Wraps a Tether WDK TRON account to implement T402's ClientTronSigner interface.
  * This allows WDK-managed TRON wallets to be used for T402 payments.
+ *
+ * Includes support for:
+ * - Energy estimation for dynamic fee limits
+ * - External energy delegation providers
+ * - Dynamic fee limit calculation with 20% margin
  */
 
 /**
@@ -42,6 +47,22 @@ interface ClientTronSigner {
     signTransaction(params: SignTransactionParams): Promise<string>;
     getBlockInfo(): Promise<BlockInfo>;
 }
+/**
+ * Energy estimation result
+ */
+interface EnergyEstimate {
+    energyRequired: number;
+    energyAvailable: number;
+    trxCostIfNoEnergy: bigint;
+    bandwidthRequired: number;
+}
+/**
+ * Energy provider interface for external delegation services
+ */
+interface EnergyProvider {
+    delegateEnergy(to: string, amount: number): Promise<string>;
+    getPrice(amount: number): Promise<bigint>;
+}
 /**
  * WDKTronSignerAdapter - Adapts a WDK TRON account to T402's ClientTronSigner
  *
@@ -60,6 +81,7 @@ declare class WDKTronSignerAdapter implements ClientTronSigner {
     private _address;
     private _initialized;
     private _rpcUrl;
+    private _energyProvider;
     constructor(account: WDKTronAccount, rpcUrl?: string);
     /**
      * Get the wallet address (T-prefix base58check)
@@ -92,6 +114,39 @@ declare class WDKTronSignerAdapter implements ClientTronSigner {
      * This is required for TRON's replay protection mechanism
      */
     getBlockInfo(): Promise<BlockInfo>;
+    /**
+     * Estimate the energy required for a TRC20 transfer.
+     *
+     * Uses the `wallet/triggerconstantcontract` API to simulate the transfer
+     * and return the energy/bandwidth requirements.
+     *
+     * @param params - Transaction parameters to simulate
+     * @returns Energy estimation result
+     */
+    estimateEnergy(params: SignTransactionParams): Promise<EnergyEstimate>;
+    /**
+     * Sign a TRC20 transfer with dynamic fee limit estimation.
+     *
+     * Instead of using a hardcoded 100 TRX fee limit, estimates the actual
+     * energy cost and adds a 20% margin.
+     *
+     * @param params - Transaction parameters
+     * @returns Hex-encoded signed transaction
+     */
+    signTransactionWithEstimation(params: SignTransactionParams): Promise<string>;
+    /**
+     * Register an external energy delegation provider.
+     *
+     * Energy providers can delegate bandwidth and energy to this account
+     * to reduce TRX costs for TRC20 transfers.
+     *
+     * @param provider - Energy delegation provider
+     */
+    registerEnergyProvider(provider: EnergyProvider): void;
+    /**
+     * Get the registered energy provider, if any
+     */
+    getEnergyProvider(): EnergyProvider | null;
     /**
      * Build a TRC20 transfer transaction
      */
@@ -136,4 +191,4 @@ declare class WDKTronSignerAdapter implements ClientTronSigner {
  */
 declare function createWDKTronSigner(account: WDKTronAccount, rpcUrl?: string): Promise<WDKTronSignerAdapter>;
 
-export { type BlockInfo, type ClientTronSigner, type SignTransactionParams, WDKTronSignerAdapter, createWDKTronSigner };
+export { type BlockInfo, type ClientTronSigner, type EnergyEstimate, type EnergyProvider, type SignTransactionParams, WDKTronSignerAdapter, createWDKTronSigner };

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

@@ -1,7 +1,8 @@
 import {
   WDKTronSignerAdapter,
   createWDKTronSigner
-} from "../chunk-HB2DGKQ3.mjs";
+} from "../chunk-QZKUU2O6.mjs";
+import "../chunk-BJTO5JO5.mjs";
 export {
   WDKTronSignerAdapter,
   createWDKTronSigner