@t402/wdk 2.3.0 → 2.4.0

package/dist/cjs/index.js

@@ -61,11 +61,20 @@ __export(index_exports, {
   WDKErrorCode: () => WDKErrorCode,
   WDKInitializationError: () => WDKInitializationError,
   WDKSigner: () => WDKSigner,
+  WDKSvmSignerAdapter: () => WDKSvmSignerAdapter,
+  WDKTonSignerAdapter: () => WDKTonSignerAdapter,
+  WDKTronSignerAdapter: () => WDKTronSignerAdapter,
+  WDK_COMPATIBILITY: () => WDK_COMPATIBILITY,
   WdkBridge: () => WdkBridge,
+  checkWalletEvmCompatibility: () => checkWalletEvmCompatibility,
+  checkWdkCompatibility: () => checkWdkCompatibility,
   createDirectBridge: () => createDirectBridge,
   createLedgerSigner: () => createLedgerSigner,
   createTrezorSigner: () => createTrezorSigner,
   createWDKSigner: () => createWDKSigner,
+  createWDKSvmSigner: () => createWDKSvmSigner,
+  createWDKTonSigner: () => createWDKTonSigner,
+  createWDKTronSigner: () => createWDKTronSigner,
   detectHardwareWalletSupport: () => detectHardwareWalletSupport,
   getBridgeableChains: () => import_evm3.getBridgeableChains,
   getChainFromNetwork: () => getChainFromNetwork,
@@ -73,6 +82,7 @@ __export(index_exports, {
   getNetworkFromChain: () => getNetworkFromChain,
   getPreferredToken: () => getPreferredToken,
   getUsdt0Chains: () => getUsdt0Chains,
+  getWalletModuleMinVersion: () => getWalletModuleMinVersion,
   hasErrorCode: () => hasErrorCode,
   isHardwareWalletSupported: () => isHardwareWalletSupported,
   isWDKError: () => isWDKError,
@@ -84,6 +94,411 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/adapters/ton-adapter.ts
+var WDKTonAddress = class {
+  constructor(_address) {
+    this._address = _address;
+  }
+  toString() {
+    return this._address;
+  }
+  toRawString() {
+    return this._address;
+  }
+};
+var WDKTonSignerAdapter = class {
+  _account;
+  _address = null;
+  _initialized = false;
+  constructor(account) {
+    if (!account) {
+      throw new Error("WDK TON account is required");
+    }
+    this._account = account;
+  }
+  /**
+   * Get the wallet address
+   * @throws Error if not initialized
+   */
+  get address() {
+    if (!this._address) {
+      throw new Error(
+        "TON signer not initialized. Call initialize() first or use createWDKTonSigner()."
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Check if the adapter is initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the adapter by fetching the address
+   * Must be called before using the signer
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+    const addressStr = await this._account.getAddress();
+    this._address = new WDKTonAddress(addressStr);
+    this._initialized = true;
+  }
+  /**
+   * Sign an internal message for Jetton transfer
+   *
+   * Attempts to build a proper signed Cell using @ton/core if available.
+   * Falls back to a simplified wrapper that embeds the raw signature.
+   *
+   * @param params - Message parameters
+   * @returns Signed external message as Cell (BOC)
+   */
+  async signMessage(params) {
+    const msgHash = params.body.hash();
+    const signature = await this._account.signMessage(msgHash);
+    try {
+      const tonCore = await import("@ton/core");
+      const sigBuffer = Buffer.from(signature.buffer, signature.byteOffset, signature.byteLength);
+      const bodyBoc = params.body.toBoc();
+      const bocBuffer = Buffer.from(bodyBoc.buffer, bodyBoc.byteOffset, bodyBoc.byteLength);
+      const signedCell = tonCore.beginCell().storeBuffer(sigBuffer).storeSlice(tonCore.Cell.fromBoc(bocBuffer)[0].beginParse()).endCell();
+      return signedCell;
+    } catch {
+      return {
+        hash: () => msgHash,
+        toBoc: () => signature
+      };
+    }
+  }
+  /**
+   * Get current seqno for the wallet
+   * Used for replay protection
+   */
+  async getSeqno() {
+    return this._account.getSeqno();
+  }
+  /**
+   * Get TON balance in nanoTON
+   */
+  async getBalance() {
+    return this._account.getBalance();
+  }
+  /**
+   * Get Jetton balance
+   * @param jettonMaster - Jetton master contract address
+   */
+  async getJettonBalance(jettonMaster) {
+    return this._account.getJettonBalance(jettonMaster);
+  }
+  /**
+   * Get the underlying WDK account
+   * Useful for advanced operations not covered by this adapter
+   */
+  getWDKAccount() {
+    return this._account;
+  }
+};
+async function createWDKTonSigner(account) {
+  const adapter = new WDKTonSignerAdapter(account);
+  await adapter.initialize();
+  return adapter;
+}
+
+// src/adapters/svm-adapter.ts
+var WDKSvmSignerAdapter = class {
+  _account;
+  _address = null;
+  _initialized = false;
+  constructor(account) {
+    if (!account) {
+      throw new Error("WDK Solana account is required");
+    }
+    this._account = account;
+  }
+  /**
+   * Get the wallet address (base58)
+   * @throws Error if not initialized
+   */
+  get address() {
+    if (!this._address) {
+      throw new Error(
+        "Solana signer not initialized. Call initialize() first or use createWDKSvmSigner()."
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Check if the adapter is initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the adapter by fetching the address
+   * Must be called before using the signer
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+    const addressStr = await this._account.getAddress();
+    this._address = addressStr;
+    this._initialized = true;
+  }
+  /**
+   * 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
+   */
+  async signTransactions(transactions) {
+    if (!transactions || transactions.length === 0) {
+      return [];
+    }
+    const results = [];
+    for (const tx of transactions) {
+      if (!tx.messageBytes || tx.messageBytes.length === 0) {
+        throw new Error("Transaction messageBytes must not be empty");
+      }
+      const signature = await this._account.sign(tx.messageBytes);
+      results.push({
+        [this._address]: signature
+      });
+    }
+    return results;
+  }
+  /**
+   * Sign a single message (utility method)
+   * @param message - Message bytes to sign
+   * @returns Signature bytes
+   */
+  async sign(message) {
+    return this._account.sign(message);
+  }
+  /**
+   * Get SOL balance in lamports
+   */
+  async getBalance() {
+    return this._account.getBalance();
+  }
+  /**
+   * Get SPL token balance
+   * @param mint - Token mint address
+   */
+  async getTokenBalance(mint) {
+    return this._account.getTokenBalance(mint);
+  }
+  /**
+   * Transfer SPL tokens
+   * @param params - Transfer parameters
+   * @returns Transaction signature
+   */
+  async transfer(params) {
+    return this._account.transfer(params);
+  }
+};
+async function createWDKSvmSigner(account) {
+  const adapter = new WDKSvmSignerAdapter(account);
+  await adapter.initialize();
+  return adapter;
+}
+
+// src/adapters/tron-adapter.ts
+var WDKTronSignerAdapter = class {
+  _account;
+  _address = null;
+  _initialized = false;
+  _rpcUrl;
+  constructor(account, rpcUrl = "https://api.trongrid.io") {
+    if (!account) {
+      throw new Error("WDK TRON account is required");
+    }
+    this._account = account;
+    this._rpcUrl = rpcUrl;
+  }
+  /**
+   * Get the wallet address (T-prefix base58check)
+   * @throws Error if not initialized
+   */
+  get address() {
+    if (!this._address) {
+      throw new Error(
+        "TRON signer not initialized. Call initialize() first or use createWDKTronSigner()."
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Check if the adapter is initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the adapter by fetching the address
+   * Must be called before using the signer
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+    this._address = await this._account.getAddress();
+    this._initialized = true;
+  }
+  /**
+   * Sign a TRC20 transfer transaction
+   *
+   * This method:
+   * 1. Builds a TRC20 transfer transaction
+   * 2. Signs it using the WDK account
+   * 3. Returns the hex-encoded signed transaction
+   *
+   * @param params - Transaction parameters
+   * @returns Hex-encoded signed transaction
+   */
+  async signTransaction(params) {
+    if (!params.contractAddress) {
+      throw new Error("contractAddress is required");
+    }
+    if (!params.to) {
+      throw new Error("recipient address (to) is required");
+    }
+    if (!params.amount || BigInt(params.amount) <= 0n) {
+      throw new Error("amount must be a positive value");
+    }
+    const blockInfo = await this.getBlockInfo();
+    const feeLimit = params.feeLimit ?? 1e8;
+    const transaction = await this.buildTrc20Transaction({
+      contractAddress: params.contractAddress,
+      to: params.to,
+      amount: params.amount,
+      feeLimit,
+      refBlockBytes: blockInfo.refBlockBytes,
+      refBlockHash: blockInfo.refBlockHash,
+      expiration: params.expiration ?? blockInfo.expiration
+    });
+    const signedTx = await this._account.signTransaction(transaction);
+    return this.serializeTransaction(signedTx);
+  }
+  /**
+   * Get the current reference block info for transaction building
+   * This is required for TRON's replay protection mechanism
+   */
+  async getBlockInfo() {
+    try {
+      const response = await fetch(`${this._rpcUrl}/wallet/getnowblock`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({})
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to get block info: ${response.status}`);
+      }
+      const block = await response.json();
+      const blockNum = block.block_header.raw_data.number;
+      const refBlockBytes = blockNum.toString(16).padStart(8, "0").slice(-4);
+      const refBlockHash = block.blockID.slice(16, 32);
+      const expiration = block.block_header.raw_data.timestamp + 6e4;
+      return {
+        refBlockBytes,
+        refBlockHash,
+        expiration
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get TRON block info: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Build a TRC20 transfer transaction
+   */
+  async buildTrc20Transaction(params) {
+    const functionSelector = "transfer(address,uint256)";
+    const toAddressHex = this.addressToHex(params.to).slice(2).padStart(64, "0");
+    const amountHex = BigInt(params.amount).toString(16).padStart(64, "0");
+    const parameter = toAddressHex + amountHex;
+    try {
+      const response = await fetch(`${this._rpcUrl}/wallet/triggersmartcontract`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          owner_address: this.addressToHex(this._address),
+          contract_address: this.addressToHex(params.contractAddress),
+          function_selector: functionSelector,
+          parameter,
+          fee_limit: params.feeLimit
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to build transaction: ${response.status}`);
+      }
+      const result = await response.json();
+      if (result.result?.code) {
+        throw new Error(`Transaction build failed: ${result.result.message}`);
+      }
+      return result.transaction;
+    } catch (error) {
+      throw new Error(
+        `Failed to build TRC20 transaction: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Serialize a signed transaction to hex format
+   */
+  serializeTransaction(signedTx) {
+    if (signedTx.signature && signedTx.signature.length > 0) {
+      return JSON.stringify(signedTx);
+    }
+    return signedTx.raw_data_hex;
+  }
+  /**
+   * Convert TRON base58 address to hex format
+   */
+  addressToHex(address) {
+    if (address.startsWith("41") || address.startsWith("0x")) {
+      return address.startsWith("0x") ? "41" + address.slice(2) : address;
+    }
+    const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let num = BigInt(0);
+    for (const char of address) {
+      num = num * BigInt(58) + BigInt(ALPHABET.indexOf(char));
+    }
+    let hex = num.toString(16);
+    let leadingZeros = 0;
+    for (const char of address) {
+      if (char === "1") leadingZeros++;
+      else break;
+    }
+    hex = "00".repeat(leadingZeros) + hex;
+    return hex.slice(0, 42);
+  }
+  /**
+   * Get TRX balance in SUN
+   */
+  async getBalance() {
+    return this._account.getBalance();
+  }
+  /**
+   * Get TRC20 token balance
+   * @param contractAddress - TRC20 contract address
+   */
+  async getTrc20Balance(contractAddress) {
+    return this._account.getTrc20Balance(contractAddress);
+  }
+};
+async function createWDKTronSigner(account, rpcUrl) {
+  const adapter = new WDKTronSignerAdapter(account, rpcUrl);
+  await adapter.initialize();
+  return adapter;
+}
+
 // src/cache.ts
 var DEFAULT_CACHE_CONFIG = {
   defaultTTL: 3e4,
@@ -573,6 +988,11 @@ var DEFAULT_CHAINS = {
     network: "eip155:130",
     name: "unichain"
   },
+  optimism: {
+    chainId: 10,
+    network: "eip155:10",
+    name: "optimism"
+  },
   polygon: {
     chainId: 137,
     network: "eip155:137",
@@ -584,6 +1004,7 @@ var DEFAULT_RPC_ENDPOINTS = {
   arbitrum: "https://arb1.arbitrum.io/rpc",
   base: "https://mainnet.base.org",
   ink: "https://rpc-gel.inkonchain.com",
+  optimism: "https://mainnet.optimism.io",
   polygon: "https://polygon-rpc.com"
 };
 var USDT0_ADDRESSES = {
@@ -591,7 +1012,7 @@ var USDT0_ADDRESSES = {
   arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
   ink: "0x0200C29006150606B650577BBE7B6248F58470c1",
   berachain: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
-  unichain: "0x588ce4F028D8e7B53B687865d6A67b3A54C75518"
+  unichain: "0x9151434b16b9763660705744891fA906F660EcC5"
 };
 var USDC_ADDRESSES = {
   ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -770,6 +1191,9 @@ var WDKErrorCode = /* @__PURE__ */ ((WDKErrorCode2) => {
   WDKErrorCode2[WDKErrorCode2["RPC_TIMEOUT"] = 8002] = "RPC_TIMEOUT";
   WDKErrorCode2[WDKErrorCode2["RPC_RATE_LIMITED"] = 8003] = "RPC_RATE_LIMITED";
   WDKErrorCode2[WDKErrorCode2["RPC_CONNECTION_FAILED"] = 8004] = "RPC_CONNECTION_FAILED";
+  WDKErrorCode2[WDKErrorCode2["PROTOCOL_NOT_REGISTERED"] = 8101] = "PROTOCOL_NOT_REGISTERED";
+  WDKErrorCode2[WDKErrorCode2["PROTOCOL_EXECUTION_FAILED"] = 8102] = "PROTOCOL_EXECUTION_FAILED";
+  WDKErrorCode2[WDKErrorCode2["INVALID_PARAMETER"] = 8103] = "INVALID_PARAMETER";
   WDKErrorCode2[WDKErrorCode2["UNKNOWN_ERROR"] = 9999] = "UNKNOWN_ERROR";
   return WDKErrorCode2;
 })(WDKErrorCode || {});
@@ -1351,6 +1775,13 @@ var WDKSigner = class {
     }
     try {
       const account = await this.getAccount();
+      if (!account.estimateGas) {
+        throw new TransactionError(
+          6002 /* GAS_ESTIMATION_FAILED */,
+          `Gas estimation is not supported by this WDK account on ${this._chain}`,
+          { chain: this._chain, context: { to: params.to } }
+        );
+      }
       return await withRetry(async () => {
         const estimatePromise = account.estimateGas({
           to: params.to,
@@ -1455,24 +1886,45 @@ var T402WDK = class _T402WDK {
   static _WDK = null;
   static _WalletManagerEvm = null;
   static _BridgeUsdt0Evm = null;
+  // Multi-chain wallet module storage
+  static _WalletModules = {};
+  static _ProtocolModules = {};
+  // Multi-chain signer caches
+  _tonSignerCache = /* @__PURE__ */ new Map();
+  _svmSignerCache = /* @__PURE__ */ new Map();
+  _tronSignerCache = /* @__PURE__ */ new Map();
   /**
    * Register the Tether WDK modules
    *
    * This must be called before creating T402WDK instances if you want
    * to use the actual WDK. Otherwise, a mock implementation is used.
    *
-   * @throws {WDKInitializationError} If registration fails
+   * Supports two registration patterns:
    *
-   * @example
-   * ```typescript
-   * import WDK from '@tetherto/wdk';
-   * import WalletManagerEvm from '@tetherto/wdk-wallet-evm';
-   * import BridgeUsdt0Evm from '@tetherto/wdk-protocol-bridge-usdt0-evm';
+   * 1. Legacy (EVM-only):
+   *    ```typescript
+   *    T402WDK.registerWDK(WDK, WalletManagerEvm, BridgeUsdt0Evm);
+   *    ```
    *
-   * T402WDK.registerWDK(WDK, WalletManagerEvm, BridgeUsdt0Evm);
-   * ```
+   * 2. Unified (multi-chain):
+   *    ```typescript
+   *    T402WDK.registerWDK(WDK, {
+   *      wallets: {
+   *        evm: WalletManagerEvm,
+   *        ton: WalletManagerTon,
+   *        solana: WalletManagerSolana,
+   *        tron: WalletManagerTron,
+   *      },
+   *      protocols: {
+   *        bridgeUsdt0Evm: BridgeUsdt0Evm,
+   *        bridgeUsdt0Ton: BridgeUsdt0Ton,
+   *      }
+   *    });
+   *    ```
+   *
+   * @throws {WDKInitializationError} If registration fails
    */
-  static registerWDK(WDK, WalletManagerEvm, BridgeUsdt0Evm) {
+  static registerWDK(WDK, modulesOrWalletManager, BridgeUsdt0Evm) {
     if (!WDK) {
       throw new WDKInitializationError("WDK constructor is required");
     }
@@ -1480,8 +1932,18 @@ var T402WDK = class _T402WDK {
       throw new WDKInitializationError("WDK must be a constructor function");
     }
     _T402WDK._WDK = WDK;
-    _T402WDK._WalletManagerEvm = WalletManagerEvm ?? null;
-    _T402WDK._BridgeUsdt0Evm = BridgeUsdt0Evm ?? null;
+    if (modulesOrWalletManager && typeof modulesOrWalletManager === "object" && ("wallets" in modulesOrWalletManager || "protocols" in modulesOrWalletManager)) {
+      const modules = modulesOrWalletManager;
+      _T402WDK._WalletModules = modules.wallets ?? {};
+      _T402WDK._ProtocolModules = modules.protocols ?? {};
+      _T402WDK._WalletManagerEvm = modules.wallets?.evm ?? null;
+      _T402WDK._BridgeUsdt0Evm = modules.protocols?.bridgeUsdt0Evm ?? null;
+    } else {
+      _T402WDK._WalletManagerEvm = modulesOrWalletManager ?? null;
+      _T402WDK._BridgeUsdt0Evm = BridgeUsdt0Evm ?? null;
+      _T402WDK._WalletModules = { evm: modulesOrWalletManager };
+      _T402WDK._ProtocolModules = { bridgeUsdt0Evm: BridgeUsdt0Evm };
+    }
   }
   /**
    * Check if WDK is registered
@@ -1501,6 +1963,40 @@ var T402WDK = class _T402WDK {
   static isBridgeRegistered() {
     return _T402WDK._BridgeUsdt0Evm !== null;
   }
+  /**
+   * Check if TON wallet manager is registered
+   */
+  static isTonRegistered() {
+    return _T402WDK._WalletModules.ton !== void 0;
+  }
+  /**
+   * Check if Solana wallet manager is registered
+   */
+  static isSolanaRegistered() {
+    return _T402WDK._WalletModules.solana !== void 0;
+  }
+  /**
+   * Check if TRON wallet manager is registered
+   */
+  static isTronRegistered() {
+    return _T402WDK._WalletModules.tron !== void 0;
+  }
+  /**
+   * Get all registered wallet modules
+   */
+  static getRegisteredWalletModules() {
+    return Object.keys(_T402WDK._WalletModules).filter(
+      (key) => _T402WDK._WalletModules[key] !== void 0
+    );
+  }
+  /**
+   * Get all registered protocol modules
+   */
+  static getRegisteredProtocolModules() {
+    return Object.keys(_T402WDK._ProtocolModules).filter(
+      (key) => _T402WDK._ProtocolModules[key] !== void 0
+    );
+  }
   /**
    * Generate a new random seed phrase
    *
@@ -1522,6 +2018,124 @@ var T402WDK = class _T402WDK {
       );
     }
   }
+  /**
+   * Quick setup: seed phrase + chains + modules → ready-to-use T402WDK.
+   *
+   * Registers all provided wallet/protocol modules and creates a fully
+   * configured instance in a single call.
+   *
+   * @example
+   * ```typescript
+   * import WDK from '@tetherto/wdk';
+   * import WalletManagerEvm from '@tetherto/wdk-wallet-evm';
+   * import BridgeUsdt0Evm from '@tetherto/wdk-protocol-bridge-usdt0-evm';
+   *
+   * const wallet = T402WDK.create({
+   *   seedPhrase: 'your twelve word seed phrase ...',
+   *   chains: {
+   *     arbitrum: 'https://arb1.arbitrum.io/rpc',
+   *     base: 'https://mainnet.base.org',
+   *   },
+   *   modules: {
+   *     wallets: { evm: WalletManagerEvm },
+   *     protocols: { bridgeUsdt0Evm: BridgeUsdt0Evm },
+   *   },
+   * });
+   * ```
+   */
+  static create(WDK, config) {
+    _T402WDK.registerWDK(WDK, config.modules);
+    return new _T402WDK(config.seedPhrase, config.chains, config.options);
+  }
+  /**
+   * Create a T402WDK from a pre-configured @tetherto/wdk instance.
+   *
+   * Wraps an existing WDK instance (already has wallets/protocols registered)
+   * into a T402WDK without re-registering modules.
+   *
+   * @param wdkInstance - A pre-configured WDK instance
+   * @param config - EVM chain configuration (RPC endpoints)
+   * @param options - Additional options
+   */
+  static fromWDK(wdkInstance, config = {}, options) {
+    if (!wdkInstance) {
+      throw new WDKInitializationError("WDK instance is required");
+    }
+    const instance = new _T402WDK("__from_wdk__", config, options);
+    instance._wdk = wdkInstance;
+    instance._initializationError = null;
+    return instance;
+  }
+  /**
+   * Get all signers as an array ready for T402 HTTP clients.
+   *
+   * Returns signer entries for all configured EVM chains, plus any
+   * registered non-EVM chains (TON, Solana, TRON).
+   *
+   * @example
+   * ```typescript
+   * const signers = await wallet.getAllSigners();
+   * const client = createT402HTTPClient({ signers });
+   * ```
+   */
+  async getAllSigners(options) {
+    const accountIndex = options?.accountIndex ?? 0;
+    const schemes = options?.schemes ?? ["exact"];
+    const includeNonEvm = options?.includeNonEvm ?? true;
+    const entries = [];
+    for (const chain of this.getConfiguredChains()) {
+      const config = this._normalizedChains.get(chain);
+      if (!config) continue;
+      try {
+        const signer = await this.getSigner(chain, accountIndex);
+        for (const scheme of schemes) {
+          entries.push({
+            scheme,
+            network: config.network,
+            signer,
+            family: "evm"
+          });
+        }
+      } catch {
+      }
+    }
+    if (!includeNonEvm) {
+      return entries;
+    }
+    if (_T402WDK.isTonRegistered()) {
+      try {
+        const signer = await this.getTonSigner(accountIndex);
+        for (const scheme of schemes) {
+          entries.push({ scheme, network: "ton:mainnet", signer, family: "ton" });
+        }
+      } catch {
+      }
+    }
+    if (_T402WDK.isSolanaRegistered()) {
+      try {
+        const signer = await this.getSvmSigner(accountIndex);
+        for (const scheme of schemes) {
+          entries.push({
+            scheme,
+            network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+            signer,
+            family: "svm"
+          });
+        }
+      } catch {
+      }
+    }
+    if (_T402WDK.isTronRegistered()) {
+      try {
+        const signer = await this.getTronSigner(accountIndex);
+        for (const scheme of schemes) {
+          entries.push({ scheme, network: "tron:mainnet", signer, family: "tron" });
+        }
+      } catch {
+      }
+    }
+    return entries;
+  }
   /**
    * Create a new T402WDK instance
    *
@@ -1531,16 +2145,19 @@ var T402WDK = class _T402WDK {
    * @throws {WDKInitializationError} If seed phrase is invalid
    */
   constructor(seedPhrase, config = {}, options = {}) {
-    if (!seedPhrase || typeof seedPhrase !== "string") {
-      throw new WDKInitializationError("Seed phrase is required and must be a string");
-    }
-    const words = seedPhrase.trim().split(/\s+/);
-    const validWordCounts = [12, 15, 18, 21, 24];
-    if (!validWordCounts.includes(words.length)) {
-      throw new WDKInitializationError(
-        `Invalid seed phrase: expected 12, 15, 18, 21, or 24 words, got ${words.length}`,
-        { context: { wordCount: words.length } }
-      );
+    const isFromWDK = seedPhrase === "__from_wdk__";
+    if (!isFromWDK) {
+      if (!seedPhrase || typeof seedPhrase !== "string") {
+        throw new WDKInitializationError("Seed phrase is required and must be a string");
+      }
+      const words = seedPhrase.trim().split(/\s+/);
+      const validWordCounts = [12, 15, 18, 21, 24];
+      if (!validWordCounts.includes(words.length)) {
+        throw new WDKInitializationError(
+          `Invalid seed phrase: expected 12, 15, 18, 21, or 24 words, got ${words.length}`,
+          { context: { wordCount: words.length } }
+        );
+      }
     }
     this._seedPhrase = seedPhrase;
     this._balanceCache = new BalanceCache(options.cache);
@@ -1558,7 +2175,7 @@ var T402WDK = class _T402WDK {
       }
     }
     this._addDefaultChainsIfNeeded();
-    if (_T402WDK._WDK) {
+    if (!isFromWDK && _T402WDK._WDK) {
       this._initializeWDK();
     }
   }
@@ -1720,6 +2337,195 @@ var T402WDK = class _T402WDK {
    */
   clearSignerCache() {
     this._signerCache.clear();
+    this._tonSignerCache.clear();
+    this._svmSignerCache.clear();
+    this._tronSignerCache.clear();
+  }
+  // ========== Multi-Chain Signers ==========
+  /**
+   * Get a TON signer for T402 payments
+   *
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @throws {ChainError} If TON wallet manager is not registered
+   * @returns An initialized ClientTonSigner
+   *
+   * @example
+   * ```typescript
+   * const tonSigner = await wallet.getTonSigner();
+   *
+   * const client = createT402HTTPClient({
+   *   signers: [{ scheme: 'exact', network: 'ton:mainnet', signer: tonSigner }]
+   * });
+   * ```
+   */
+  async getTonSigner(accountIndex = 0) {
+    const cached = this._tonSignerCache.get(accountIndex);
+    if (cached) {
+      return cached;
+    }
+    if (!_T402WDK._WalletModules.ton) {
+      throw new ChainError(
+        2002 /* CHAIN_NOT_SUPPORTED */,
+        "TON wallet manager not registered. Call T402WDK.registerWDK(WDK, { wallets: { ton: WalletManagerTon } }).",
+        { chain: "ton" }
+      );
+    }
+    try {
+      const account = await this.wdk.getAccount("ton", accountIndex);
+      const signer = await createWDKTonSigner(account);
+      this._tonSignerCache.set(accountIndex, signer);
+      return signer;
+    } catch (error) {
+      if (isWDKError(error)) {
+        throw error;
+      }
+      throw wrapError(error, 3001 /* SIGNER_NOT_INITIALIZED */, "Failed to create TON signer", {
+        chain: "ton",
+        accountIndex
+      });
+    }
+  }
+  /**
+   * Get a Solana (SVM) signer for T402 payments
+   *
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @throws {ChainError} If Solana wallet manager is not registered
+   * @returns An initialized TransactionSigner (ClientSvmSigner)
+   *
+   * @example
+   * ```typescript
+   * const svmSigner = await wallet.getSvmSigner();
+   *
+   * const client = createT402HTTPClient({
+   *   signers: [{ scheme: 'exact', network: 'solana:mainnet', signer: svmSigner }]
+   * });
+   * ```
+   */
+  async getSvmSigner(accountIndex = 0) {
+    const cached = this._svmSignerCache.get(accountIndex);
+    if (cached) {
+      return cached;
+    }
+    if (!_T402WDK._WalletModules.solana) {
+      throw new ChainError(
+        2002 /* CHAIN_NOT_SUPPORTED */,
+        "Solana wallet manager not registered. Call T402WDK.registerWDK(WDK, { wallets: { solana: WalletManagerSolana } }).",
+        { chain: "solana" }
+      );
+    }
+    try {
+      const account = await this.wdk.getAccount(
+        "solana",
+        accountIndex
+      );
+      const signer = await createWDKSvmSigner(account);
+      this._svmSignerCache.set(accountIndex, signer);
+      return signer;
+    } catch (error) {
+      if (isWDKError(error)) {
+        throw error;
+      }
+      throw wrapError(
+        error,
+        3001 /* SIGNER_NOT_INITIALIZED */,
+        "Failed to create Solana signer",
+        { chain: "solana", accountIndex }
+      );
+    }
+  }
+  /**
+   * Get a TRON signer for T402 payments
+   *
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @param rpcUrl - Optional custom RPC URL (default: https://api.trongrid.io)
+   * @throws {ChainError} If TRON wallet manager is not registered
+   * @returns An initialized ClientTronSigner
+   *
+   * @example
+   * ```typescript
+   * const tronSigner = await wallet.getTronSigner();
+   *
+   * const client = createT402HTTPClient({
+   *   signers: [{ scheme: 'exact', network: 'tron:mainnet', signer: tronSigner }]
+   * });
+   * ```
+   */
+  async getTronSigner(accountIndex = 0, rpcUrl) {
+    if (!rpcUrl) {
+      const cached = this._tronSignerCache.get(accountIndex);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!_T402WDK._WalletModules.tron) {
+      throw new ChainError(
+        2002 /* CHAIN_NOT_SUPPORTED */,
+        "TRON wallet manager not registered. Call T402WDK.registerWDK(WDK, { wallets: { tron: WalletManagerTron } }).",
+        { chain: "tron" }
+      );
+    }
+    try {
+      const account = await this.wdk.getAccount("tron", accountIndex);
+      const signer = await createWDKTronSigner(account, rpcUrl);
+      if (!rpcUrl) {
+        this._tronSignerCache.set(accountIndex, signer);
+      }
+      return signer;
+    } catch (error) {
+      if (isWDKError(error)) {
+        throw error;
+      }
+      throw wrapError(error, 3001 /* SIGNER_NOT_INITIALIZED */, "Failed to create TRON signer", {
+        chain: "tron",
+        accountIndex
+      });
+    }
+  }
+  /**
+   * Get a signer for a specific chain family
+   *
+   * @param family - Chain family (evm, svm, ton, tron)
+   * @param chainOrIndex - Chain name for EVM, or account index for others
+   * @param accountIndex - Account index (only used for EVM)
+   * @throws {ChainError} If chain family is not supported or not configured
+   * @returns An appropriate signer for the chain family
+   *
+   * @example
+   * ```typescript
+   * // Get EVM signer for Arbitrum
+   * const evmSigner = await wallet.getSignerByFamily('evm', 'arbitrum');
+   *
+   * // Get TON signer
+   * const tonSigner = await wallet.getSignerByFamily('ton');
+   *
+   * // Get Solana signer with account index 1
+   * const svmSigner = await wallet.getSignerByFamily('svm', 1);
+   * ```
+   */
+  async getSignerByFamily(family, chainOrIndex, accountIndex = 0) {
+    switch (family) {
+      case "evm":
+        if (typeof chainOrIndex !== "string") {
+          throw new ChainError(
+            2003 /* INVALID_CHAIN_CONFIG */,
+            'EVM signers require a chain name (e.g., "arbitrum", "ethereum")',
+            { chain: family }
+          );
+        }
+        return this.getSigner(chainOrIndex, accountIndex);
+      case "ton":
+        return this.getTonSigner(typeof chainOrIndex === "number" ? chainOrIndex : accountIndex);
+      case "svm":
+        return this.getSvmSigner(typeof chainOrIndex === "number" ? chainOrIndex : accountIndex);
+      case "tron":
+        return this.getTronSigner(typeof chainOrIndex === "number" ? chainOrIndex : accountIndex);
+      default:
+        throw new ChainError(
+          2002 /* CHAIN_NOT_SUPPORTED */,
+          `Chain family "${family}" is not supported. Available: evm, ton, svm, tron`,
+          { chain: family }
+        );
+    }
   }
   /**
    * Get wallet address for a chain
@@ -2067,6 +2873,118 @@ var T402WDK = class _T402WDK {
     }
     return (0, import_evm.getBridgeableChains)().filter((chain) => chain !== fromChain);
   }
+  // ========== Swap Protocol ==========
+  /**
+   * Check if the Velora swap protocol is registered and available
+   */
+  canSwap() {
+    return _T402WDK._ProtocolModules.swapVeloraEvm !== void 0;
+  }
+  /**
+   * Get a swap quote for converting a token to USDT0
+   *
+   * @param chain - Chain name (e.g., "ethereum", "arbitrum")
+   * @param fromToken - Input token address
+   * @param amount - Amount to swap in smallest units
+   * @throws {WDKError} If swap protocol is not registered or quote fails
+   */
+  async getSwapQuote(chain, fromToken, amount) {
+    if (!this.canSwap()) {
+      throw new WDKError(
+        8101 /* PROTOCOL_NOT_REGISTERED */,
+        "Velora swap protocol not registered. Call T402WDK.registerWDK(WDK, { protocols: { swapVeloraEvm: SwapVeloraEvm } })."
+      );
+    }
+    const usdt0Address = USDT0_ADDRESSES[chain];
+    if (!usdt0Address) {
+      throw new ChainError(
+        2002 /* CHAIN_NOT_SUPPORTED */,
+        `Chain "${chain}" does not have a known USDT0 address`,
+        { chain }
+      );
+    }
+    try {
+      const result = await this.wdk.executeProtocol("swap-velora", {
+        action: "quote",
+        chain,
+        fromToken,
+        toToken: usdt0Address,
+        amount: amount.toString()
+      });
+      return result;
+    } catch (error) {
+      throw wrapError(
+        error,
+        8102 /* PROTOCOL_EXECUTION_FAILED */,
+        `Failed to get swap quote on ${chain}`,
+        { chain, fromToken, amount: amount.toString() }
+      );
+    }
+  }
+  /**
+   * Swap any token to USDT0 for payment
+   *
+   * Uses the Velora protocol to execute a token swap on the specified chain.
+   *
+   * @param params - Swap parameters
+   * @throws {WDKError} If swap protocol is not registered or swap fails
+   *
+   * @example
+   * ```typescript
+   * // Swap 0.1 WETH to USDT0 on Arbitrum
+   * const result = await wallet.swapAndPay({
+   *   chain: 'arbitrum',
+   *   fromToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // WETH
+   *   amount: 100000000000000000n, // 0.1 WETH
+   *   maxSlippage: 0.005,
+   * });
+   * ```
+   */
+  async swapAndPay(params) {
+    if (!this.canSwap()) {
+      throw new WDKError(
+        8101 /* PROTOCOL_NOT_REGISTERED */,
+        "Velora swap protocol not registered. Call T402WDK.registerWDK(WDK, { protocols: { swapVeloraEvm: SwapVeloraEvm } })."
+      );
+    }
+    const usdt0Address = USDT0_ADDRESSES[params.chain];
+    if (!usdt0Address) {
+      throw new ChainError(
+        2002 /* CHAIN_NOT_SUPPORTED */,
+        `Chain "${params.chain}" does not have a known USDT0 address`,
+        { chain: params.chain }
+      );
+    }
+    if (params.maxSlippage !== void 0 && (params.maxSlippage < 0 || params.maxSlippage > 0.5)) {
+      throw new WDKError(
+        8103 /* INVALID_PARAMETER */,
+        "maxSlippage must be between 0 and 0.5 (0% to 50%)"
+      );
+    }
+    try {
+      const result = await this.wdk.executeProtocol("swap-velora", {
+        action: "swap",
+        chain: params.chain,
+        fromToken: params.fromToken,
+        toToken: usdt0Address,
+        amount: params.amount.toString(),
+        maxSlippage: params.maxSlippage ?? 5e-3
+      });
+      this._balanceCache.invalidateChain(params.chain);
+      return result;
+    } catch (error) {
+      throw wrapError(
+        error,
+        8102 /* PROTOCOL_EXECUTION_FAILED */,
+        `Failed to execute swap on ${params.chain}`,
+        {
+          chain: params.chain,
+          fromToken: params.fromToken,
+          amount: params.amount.toString()
+        }
+      );
+    }
+  }
   // ========== Cache Management ==========
   /**
    * Check if balance caching is enabled
@@ -2120,6 +3038,9 @@ var T402WDK = class _T402WDK {
   dispose() {
     this._balanceCache.dispose();
     this._signerCache.clear();
+    this._tonSignerCache.clear();
+    this._svmSignerCache.clear();
+    this._tronSignerCache.clear();
   }
 };
 function formatTokenAmount(amount, decimals) {
@@ -2203,6 +3124,94 @@ function createDirectBridge(signer, chain) {
 // src/index.ts
 var import_evm3 = require("@t402/evm");
 
+// src/compatibility.ts
+var WDK_COMPATIBILITY = {
+  /** Minimum supported @tetherto/wdk version */
+  minVersion: "1.0.0-beta.0",
+  /** Versions that have been tested */
+  testedVersions: ["1.0.0-beta.3", "1.0.0-beta.4", "1.0.0-beta.5"],
+  /** Tested wallet-evm module versions */
+  walletEvmVersions: ["1.0.0-beta.5", "2.0.0-rc.1"],
+  /** Feature availability by @tetherto/wdk core version */
+  features: {
+    signTypedData: "1.0.0-beta.0",
+    estimateGas: "1.0.0-beta.3",
+    multiChainWallets: "1.0.0-beta.0",
+    bridgeProtocol: "1.0.0-beta.3",
+    swapProtocol: "1.0.0-beta.4"
+  },
+  /** Known wallet module minimum versions */
+  walletModuleVersions: {
+    evm: "1.0.0-beta.5",
+    ton: "1.0.0-beta.7",
+    btc: "1.0.0-beta.5",
+    tron: "1.0.0-beta.4",
+    solana: "1.0.0-beta.5",
+    spark: "1.0.0-beta.6"
+  }
+};
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+  if (!match) {
+    return { major: 0, minor: 0, patch: 0, prerelease: "" };
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    prerelease: match[4] ?? ""
+  };
+}
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (va.major !== vb.major) return va.major < vb.major ? -1 : 1;
+  if (va.minor !== vb.minor) return va.minor < vb.minor ? -1 : 1;
+  if (va.patch !== vb.patch) return va.patch < vb.patch ? -1 : 1;
+  if (va.prerelease && !vb.prerelease) return -1;
+  if (!va.prerelease && vb.prerelease) return 1;
+  if (va.prerelease && vb.prerelease) {
+    return va.prerelease < vb.prerelease ? -1 : va.prerelease > vb.prerelease ? 1 : 0;
+  }
+  return 0;
+}
+function checkWdkCompatibility(version) {
+  const warnings = [];
+  if (compareVersions(version, WDK_COMPATIBILITY.minVersion) < 0) {
+    return {
+      compatible: false,
+      warnings: [
+        `@tetherto/wdk ${version} is below minimum supported version ${WDK_COMPATIBILITY.minVersion}`
+      ]
+    };
+  }
+  const isTested = WDK_COMPATIBILITY.testedVersions.includes(version);
+  if (!isTested) {
+    warnings.push(
+      `@tetherto/wdk ${version} has not been explicitly tested. Tested versions: ${WDK_COMPATIBILITY.testedVersions.join(", ")}`
+    );
+  }
+  for (const [feature, minFeatureVersion] of Object.entries(WDK_COMPATIBILITY.features)) {
+    if (compareVersions(version, minFeatureVersion) < 0) {
+      warnings.push(`Feature '${feature}' requires @tetherto/wdk >= ${minFeatureVersion}`);
+    }
+  }
+  return { compatible: true, warnings };
+}
+function checkWalletEvmCompatibility(version) {
+  const warnings = [];
+  const isTested = WDK_COMPATIBILITY.walletEvmVersions.includes(version);
+  if (!isTested) {
+    warnings.push(
+      `@tetherto/wdk-wallet-evm ${version} has not been explicitly tested. Tested versions: ${WDK_COMPATIBILITY.walletEvmVersions.join(", ")}`
+    );
+  }
+  return { compatible: true, warnings };
+}
+function getWalletModuleMinVersion(module2) {
+  return WDK_COMPATIBILITY.walletModuleVersions[module2];
+}
+
 // src/hardware/types.ts
 var HardwareWalletErrorCode = /* @__PURE__ */ ((HardwareWalletErrorCode2) => {
   HardwareWalletErrorCode2["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
@@ -2858,11 +3867,20 @@ function isHardwareWalletSupported() {
   WDKErrorCode,
   WDKInitializationError,
   WDKSigner,
+  WDKSvmSignerAdapter,
+  WDKTonSignerAdapter,
+  WDKTronSignerAdapter,
+  WDK_COMPATIBILITY,
   WdkBridge,
+  checkWalletEvmCompatibility,
+  checkWdkCompatibility,
   createDirectBridge,
   createLedgerSigner,
   createTrezorSigner,
   createWDKSigner,
+  createWDKSvmSigner,
+  createWDKTonSigner,
+  createWDKTronSigner,
   detectHardwareWalletSupport,
   getBridgeableChains,
   getChainFromNetwork,
@@ -2870,6 +3888,7 @@ function isHardwareWalletSupported() {
   getNetworkFromChain,
   getPreferredToken,
   getUsdt0Chains,
+  getWalletModuleMinVersion,
   hasErrorCode,
   isHardwareWalletSupported,
   isWDKError,