@t402/wdk 2.3.0 → 2.4.0

package/dist/esm/index.mjs

@@ -1,3 +1,16 @@
+import {
+  WDKSvmSignerAdapter,
+  createWDKSvmSigner
+} from "./chunk-MCFHZSF7.mjs";
+import {
+  WDKTonSignerAdapter,
+  createWDKTonSigner
+} from "./chunk-YWBJJV5M.mjs";
+import {
+  WDKTronSignerAdapter,
+  createWDKTronSigner
+} from "./chunk-HB2DGKQ3.mjs";
+
 // src/cache.ts
 var DEFAULT_CACHE_CONFIG = {
   defaultTTL: 3e4,
@@ -487,6 +500,11 @@ var DEFAULT_CHAINS = {
     network: "eip155:130",
     name: "unichain"
   },
+  optimism: {
+    chainId: 10,
+    network: "eip155:10",
+    name: "optimism"
+  },
   polygon: {
     chainId: 137,
     network: "eip155:137",
@@ -498,6 +516,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 = {
@@ -505,7 +524,7 @@ var USDT0_ADDRESSES = {
   arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
   ink: "0x0200C29006150606B650577BBE7B6248F58470c1",
   berachain: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
-  unichain: "0x588ce4F028D8e7B53B687865d6A67b3A54C75518"
+  unichain: "0x9151434b16b9763660705744891fA906F660EcC5"
 };
 var USDC_ADDRESSES = {
   ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -684,6 +703,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 || {});
@@ -1265,6 +1287,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,
@@ -1369,24 +1398,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");
     }
@@ -1394,8 +1444,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
@@ -1415,6 +1475,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
    *
@@ -1436,6 +1530,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
    *
@@ -1445,16 +1657,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);
@@ -1472,7 +1687,7 @@ var T402WDK = class _T402WDK {
       }
     }
     this._addDefaultChainsIfNeeded();
-    if (_T402WDK._WDK) {
+    if (!isFromWDK && _T402WDK._WDK) {
       this._initializeWDK();
     }
   }
@@ -1634,6 +1849,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
@@ -1981,6 +2385,118 @@ var T402WDK = class _T402WDK {
     }
     return 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
@@ -2034,6 +2550,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) {
@@ -2123,6 +2642,94 @@ import {
   Usdt0Bridge as Usdt0Bridge2
 } from "@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(module) {
+  return WDK_COMPATIBILITY.walletModuleVersions[module];
+}
+
 // src/hardware/types.ts
 var HardwareWalletErrorCode = /* @__PURE__ */ ((HardwareWalletErrorCode2) => {
   HardwareWalletErrorCode2["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
@@ -2777,11 +3384,20 @@ export {
   WDKErrorCode,
   WDKInitializationError,
   WDKSigner,
+  WDKSvmSignerAdapter,
+  WDKTonSignerAdapter,
+  WDKTronSignerAdapter,
+  WDK_COMPATIBILITY,
   WdkBridge,
+  checkWalletEvmCompatibility,
+  checkWdkCompatibility,
   createDirectBridge,
   createLedgerSigner,
   createTrezorSigner,
   createWDKSigner,
+  createWDKSvmSigner,
+  createWDKTonSigner,
+  createWDKTronSigner,
   detectHardwareWalletSupport,
   getBridgeableChains3 as getBridgeableChains,
   getChainFromNetwork,
@@ -2789,6 +3405,7 @@ export {
   getNetworkFromChain,
   getPreferredToken,
   getUsdt0Chains,
+  getWalletModuleMinVersion,
   hasErrorCode,
   isHardwareWalletSupported,
   isWDKError,