@t402/wdk 2.0.0 → 2.3.0

package/dist/cjs/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -30,7 +40,10 @@ __export(index_exports, {
   DEFAULT_CHAINS: () => DEFAULT_CHAINS,
   DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
   DEFAULT_RPC_ENDPOINTS: () => DEFAULT_RPC_ENDPOINTS,
+  HardwareWalletError: () => HardwareWalletError,
+  HardwareWalletErrorCode: () => HardwareWalletErrorCode,
   LAYERZERO_ENDPOINT_IDS: () => import_evm3.LAYERZERO_ENDPOINT_IDS,
+  LedgerSigner: () => LedgerSigner,
   MockWDKSigner: () => MockWDKSigner,
   RPCError: () => RPCError,
   SignerError: () => SignerError,
@@ -38,6 +51,7 @@ __export(index_exports, {
   T402WDK: () => T402WDK,
   TTLCache: () => TTLCache,
   TransactionError: () => TransactionError,
+  TrezorSigner: () => TrezorSigner,
   USDC_ADDRESSES: () => USDC_ADDRESSES,
   USDT0_ADDRESSES: () => USDT0_ADDRESSES,
   USDT0_OFT_ADDRESSES: () => import_evm3.USDT0_OFT_ADDRESSES,
@@ -49,7 +63,10 @@ __export(index_exports, {
   WDKSigner: () => WDKSigner,
   WdkBridge: () => WdkBridge,
   createDirectBridge: () => createDirectBridge,
+  createLedgerSigner: () => createLedgerSigner,
+  createTrezorSigner: () => createTrezorSigner,
   createWDKSigner: () => createWDKSigner,
+  detectHardwareWalletSupport: () => detectHardwareWalletSupport,
   getBridgeableChains: () => import_evm3.getBridgeableChains,
   getChainFromNetwork: () => getChainFromNetwork,
   getChainId: () => getChainId,
@@ -57,6 +74,7 @@ __export(index_exports, {
   getPreferredToken: () => getPreferredToken,
   getUsdt0Chains: () => getUsdt0Chains,
   hasErrorCode: () => hasErrorCode,
+  isHardwareWalletSupported: () => isHardwareWalletSupported,
   isWDKError: () => isWDKError,
   normalizeChainConfig: () => normalizeChainConfig,
   supportsBridging: () => import_evm3.supportsBridging,
@@ -74,9 +92,10 @@ var DEFAULT_CACHE_CONFIG = {
   refreshOnAccess: false
 };
 var TTLCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _config;
+  _cleanupInterval = null;
   constructor(config = {}) {
-    this._cache = /* @__PURE__ */ new Map();
-    this._cleanupInterval = null;
     this._config = { ...DEFAULT_CACHE_CONFIG, ...config };
     if (this._config.maxSize > 0) {
       this._startCleanup();
@@ -344,6 +363,9 @@ var DEFAULT_BALANCE_CACHE_CONFIG = {
   maxSize: 500
 };
 var BalanceCache = class {
+  _cache;
+  _aggregatedCache;
+  _config;
   constructor(config = {}) {
     this._config = { ...DEFAULT_BALANCE_CACHE_CONFIG, ...config };
     this._cache = new TTLCache({
@@ -752,6 +774,9 @@ var WDKErrorCode = /* @__PURE__ */ ((WDKErrorCode2) => {
   return WDKErrorCode2;
 })(WDKErrorCode || {});
 var WDKError = class _WDKError extends Error {
+  code;
+  cause;
+  context;
   constructor(code, message, options) {
     super(message);
     this.name = "WDKError";
@@ -796,6 +821,7 @@ var WDKInitializationError = class extends WDKError {
   }
 };
 var ChainError = class extends WDKError {
+  chain;
   constructor(code, message, options) {
     super(code, message, {
       cause: options?.cause,
@@ -806,6 +832,8 @@ var ChainError = class extends WDKError {
   }
 };
 var SignerError = class extends WDKError {
+  chain;
+  address;
   constructor(code, message, options) {
     super(code, message, {
       cause: options?.cause,
@@ -817,6 +845,7 @@ var SignerError = class extends WDKError {
   }
 };
 var SigningError = class extends WDKError {
+  operation;
   constructor(code, message, options) {
     super(code, message, {
       cause: options.cause,
@@ -827,6 +856,8 @@ var SigningError = class extends WDKError {
   }
 };
 var BalanceError = class extends WDKError {
+  chain;
+  token;
   constructor(code, message, options) {
     super(code, message, {
       cause: options?.cause,
@@ -838,6 +869,8 @@ var BalanceError = class extends WDKError {
   }
 };
 var TransactionError = class extends WDKError {
+  chain;
+  txHash;
   constructor(code, message, options) {
     super(code, message, {
       cause: options?.cause,
@@ -849,6 +882,8 @@ var TransactionError = class extends WDKError {
   }
 };
 var BridgeError = class extends WDKError {
+  fromChain;
+  toChain;
   constructor(code, message, options) {
     super(code, message, {
       cause: options?.cause,
@@ -864,6 +899,8 @@ var BridgeError = class extends WDKError {
   }
 };
 var RPCError = class extends WDKError {
+  endpoint;
+  rpcCode;
   constructor(code, message, options) {
     super(code, message, {
       cause: options?.cause,
@@ -891,11 +928,10 @@ function wrapError(error, defaultCode = 9999 /* UNKNOWN_ERROR */, defaultMessage
       });
     }
     if (msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("429")) {
-      return new RPCError(
-        8003 /* RPC_RATE_LIMITED */,
-        `Rate limited: ${error.message}`,
-        { cause: error, context }
-      );
+      return new RPCError(8003 /* RPC_RATE_LIMITED */, `Rate limited: ${error.message}`, {
+        cause: error,
+        context
+      });
     }
     if (msg.includes("connection") || msg.includes("network") || msg.includes("econnrefused") || msg.includes("enotfound")) {
       return new RPCError(
@@ -973,12 +1009,7 @@ async function withTimeout(promise, timeoutMs, operation = "Operation") {
   let timeoutId;
   const timeoutPromise = new Promise((_, reject) => {
     timeoutId = setTimeout(() => {
-      reject(
-        new RPCError(
-          8002 /* RPC_TIMEOUT */,
-          `${operation} timed out after ${timeoutMs}ms`
-        )
-      );
+      reject(new RPCError(8002 /* RPC_TIMEOUT */, `${operation} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
   });
   try {
@@ -995,6 +1026,12 @@ var DEFAULT_BALANCE_RETRY = {
   baseDelay: 500
 };
 var WDKSigner = class {
+  _wdk;
+  _chain;
+  _accountIndex;
+  _account = null;
+  _address = null;
+  _timeoutMs;
   /**
    * Create a new WDK signer
    *
@@ -1004,14 +1041,8 @@ var WDKSigner = class {
    * @param timeoutMs - Timeout for operations in milliseconds (default: 30000)
    */
   constructor(wdk, chain, accountIndex = 0, timeoutMs = DEFAULT_TIMEOUT_MS) {
-    this._account = null;
-    this._address = null;
     if (!wdk) {
-      throw new SignerError(
-        1002 /* WDK_NOT_INITIALIZED */,
-        "WDK instance is required",
-        { chain }
-      );
+      throw new SignerError(1002 /* WDK_NOT_INITIALIZED */, "WDK instance is required", { chain });
     }
     if (!chain || typeof chain !== "string") {
       throw new SignerError(
@@ -1152,11 +1183,7 @@ var WDKSigner = class {
         primaryType: message.primaryType,
         message: message.message
       });
-      const signature = await withTimeout(
-        signPromise,
-        this._timeoutMs,
-        "Signing typed data"
-      );
+      const signature = await withTimeout(signPromise, this._timeoutMs, "Signing typed data");
       if (!signature || !signature.startsWith("0x")) {
         throw new SigningError(
           4001 /* SIGN_TYPED_DATA_FAILED */,
@@ -1169,19 +1196,20 @@ var WDKSigner = class {
       if (error instanceof SigningError) {
         throw error;
       }
-      const wrapped = wrapError(error, 4001 /* SIGN_TYPED_DATA_FAILED */, "Failed to sign typed data", {
-        chain: this._chain,
-        primaryType: message.primaryType
-      });
-      throw new SigningError(
-        wrapped.code,
-        wrapped.message,
+      const wrapped = wrapError(
+        error,
+        4001 /* SIGN_TYPED_DATA_FAILED */,
+        "Failed to sign typed data",
         {
-          operation: "signTypedData",
-          cause: wrapped.cause,
-          context: wrapped.context
+          chain: this._chain,
+          primaryType: message.primaryType
         }
       );
+      throw new SigningError(wrapped.code, wrapped.message, {
+        operation: "signTypedData",
+        cause: wrapped.cause,
+        context: wrapped.context
+      });
     }
   }
   /**
@@ -1191,11 +1219,10 @@ var WDKSigner = class {
    */
   async signMessage(message) {
     if (message === void 0 || message === null) {
-      throw new SigningError(
-        4004 /* INVALID_MESSAGE */,
-        "Message is required for signing",
-        { operation: "signMessage", context: { chain: this._chain } }
-      );
+      throw new SigningError(4004 /* INVALID_MESSAGE */, "Message is required for signing", {
+        operation: "signMessage",
+        context: { chain: this._chain }
+      });
     }
     if (typeof message !== "string" && !(message instanceof Uint8Array)) {
       throw new SigningError(
@@ -1208,11 +1235,7 @@ var WDKSigner = class {
       const account = await this.getAccount();
       const messageStr = typeof message === "string" ? message : Buffer.from(message).toString("utf-8");
       const signPromise = account.signMessage(messageStr);
-      const signature = await withTimeout(
-        signPromise,
-        this._timeoutMs,
-        "Signing message"
-      );
+      const signature = await withTimeout(signPromise, this._timeoutMs, "Signing message");
       if (!signature || !signature.startsWith("0x")) {
         throw new SigningError(
           4002 /* SIGN_MESSAGE_FAILED */,
@@ -1228,15 +1251,11 @@ var WDKSigner = class {
       const wrapped = wrapError(error, 4002 /* SIGN_MESSAGE_FAILED */, "Failed to sign message", {
         chain: this._chain
       });
-      throw new SigningError(
-        wrapped.code,
-        wrapped.message,
-        {
-          operation: "signMessage",
-          cause: wrapped.cause,
-          context: wrapped.context
-        }
-      );
+      throw new SigningError(wrapped.code, wrapped.message, {
+        operation: "signMessage",
+        cause: wrapped.cause,
+        context: wrapped.context
+      });
     }
   }
   /**
@@ -1265,13 +1284,10 @@ var WDKSigner = class {
   async getBalance() {
     try {
       const account = await this.getAccount();
-      return await withRetry(
-        async () => {
-          const balancePromise = account.getBalance();
-          return withTimeout(balancePromise, this._timeoutMs, "Fetching native balance");
-        },
-        DEFAULT_BALANCE_RETRY
-      );
+      return await withRetry(async () => {
+        const balancePromise = account.getBalance();
+        return withTimeout(balancePromise, this._timeoutMs, "Fetching native balance");
+      }, DEFAULT_BALANCE_RETRY);
     } catch (error) {
       if (error instanceof BalanceError) {
         throw error;
@@ -1301,13 +1317,10 @@ var WDKSigner = class {
     }
     try {
       const account = await this.getAccount();
-      return await withRetry(
-        async () => {
-          const balancePromise = account.getTokenBalance(tokenAddress);
-          return withTimeout(balancePromise, this._timeoutMs, "Fetching token balance");
-        },
-        DEFAULT_BALANCE_RETRY
-      );
+      return await withRetry(async () => {
+        const balancePromise = account.getTokenBalance(tokenAddress);
+        return withTimeout(balancePromise, this._timeoutMs, "Fetching token balance");
+      }, DEFAULT_BALANCE_RETRY);
     } catch (error) {
       if (error instanceof BalanceError) {
         throw error;
@@ -1338,17 +1351,14 @@ var WDKSigner = class {
     }
     try {
       const account = await this.getAccount();
-      return await withRetry(
-        async () => {
-          const estimatePromise = account.estimateGas({
-            to: params.to,
-            value: params.value,
-            data: params.data
-          });
-          return withTimeout(estimatePromise, this._timeoutMs, "Estimating gas");
-        },
-        DEFAULT_BALANCE_RETRY
-      );
+      return await withRetry(async () => {
+        const estimatePromise = account.estimateGas({
+          to: params.to,
+          value: params.value,
+          data: params.data
+        });
+        return withTimeout(estimatePromise, this._timeoutMs, "Estimating gas");
+      }, DEFAULT_BALANCE_RETRY);
     } catch (error) {
       if (error instanceof TransactionError) {
         throw error;
@@ -1406,15 +1416,11 @@ var WDKSigner = class {
         chain: this._chain,
         to: params.to
       });
-      throw new TransactionError(
-        wrapped.code,
-        wrapped.message,
-        {
-          chain: this._chain,
-          cause: wrapped.cause,
-          context: wrapped.context
-        }
-      );
+      throw new TransactionError(wrapped.code, wrapped.message, {
+        chain: this._chain,
+        cause: wrapped.cause,
+        context: wrapped.context
+      });
     }
   }
 };
@@ -1424,9 +1430,9 @@ async function createWDKSigner(wdk, chain, accountIndex = 0, timeoutMs = DEFAULT
   return signer;
 }
 var MockWDKSigner = class {
-  constructor(address, privateKey) {
+  address;
+  constructor(address, _privateKey) {
     this.address = address;
-    this._privateKey = privateKey;
   }
   async signTypedData(_message) {
     return "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
@@ -1438,53 +1444,17 @@ var MockWDKSigner = class {
 
 // src/t402wdk.ts
 var import_evm = require("@t402/evm");
-var _T402WDK = class _T402WDK {
-  /**
-   * Create a new T402WDK instance
-   *
-   * @param seedPhrase - BIP-39 mnemonic seed phrase
-   * @param config - Chain configuration (RPC endpoints)
-   * @param options - Additional options (cache configuration, etc.)
-   * @throws {WDKInitializationError} If seed phrase is invalid
-   */
-  constructor(seedPhrase, config = {}, options = {}) {
-    this._wdk = null;
-    this._normalizedChains = /* @__PURE__ */ new Map();
-    this._signerCache = /* @__PURE__ */ new Map();
-    this._initializationError = null;
-    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._config = config;
-    this._options = options;
-    this._balanceCache = new BalanceCache(options.cache);
-    for (const [chain, chainConfig] of Object.entries(config)) {
-      if (chainConfig) {
-        try {
-          this._normalizedChains.set(chain, normalizeChainConfig(chain, chainConfig));
-        } catch (error) {
-          throw new ChainError(
-            2003 /* INVALID_CHAIN_CONFIG */,
-            `Invalid configuration for chain "${chain}": ${error instanceof Error ? error.message : String(error)}`,
-            { chain, cause: error instanceof Error ? error : void 0 }
-          );
-        }
-      }
-    }
-    this._addDefaultChainsIfNeeded();
-    if (_T402WDK._WDK) {
-      this._initializeWDK();
-    }
-  }
+var T402WDK = class _T402WDK {
+  _wdk = null;
+  _normalizedChains = /* @__PURE__ */ new Map();
+  _seedPhrase;
+  _signerCache = /* @__PURE__ */ new Map();
+  _balanceCache;
+  _initializationError = null;
+  // WDK module references (set via registerWDK)
+  static _WDK = null;
+  static _WalletManagerEvm = null;
+  static _BridgeUsdt0Evm = null;
   /**
    * Register the Tether WDK modules
    *
@@ -1552,6 +1522,46 @@ var _T402WDK = class _T402WDK {
       );
     }
   }
+  /**
+   * Create a new T402WDK instance
+   *
+   * @param seedPhrase - BIP-39 mnemonic seed phrase
+   * @param config - Chain configuration (RPC endpoints)
+   * @param options - Additional options (cache configuration, etc.)
+   * @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 } }
+      );
+    }
+    this._seedPhrase = seedPhrase;
+    this._balanceCache = new BalanceCache(options.cache);
+    for (const [chain, chainConfig] of Object.entries(config)) {
+      if (chainConfig) {
+        try {
+          this._normalizedChains.set(chain, normalizeChainConfig(chain, chainConfig));
+        } catch (error) {
+          throw new ChainError(
+            2003 /* INVALID_CHAIN_CONFIG */,
+            `Invalid configuration for chain "${chain}": ${error instanceof Error ? error.message : String(error)}`,
+            { chain, cause: error instanceof Error ? error : void 0 }
+          );
+        }
+      }
+    }
+    this._addDefaultChainsIfNeeded();
+    if (_T402WDK._WDK) {
+      this._initializeWDK();
+    }
+  }
   /**
    * Add default chain configurations for common chains
    */
@@ -1559,10 +1569,7 @@ var _T402WDK = class _T402WDK {
     if (this._normalizedChains.size === 0) {
       const defaultEndpoint = DEFAULT_RPC_ENDPOINTS.arbitrum;
       if (defaultEndpoint) {
-        this._normalizedChains.set(
-          "arbitrum",
-          normalizeChainConfig("arbitrum", defaultEndpoint)
-        );
+        this._normalizedChains.set("arbitrum", normalizeChainConfig("arbitrum", defaultEndpoint));
       }
     }
   }
@@ -1793,11 +1800,9 @@ var _T402WDK = class _T402WDK {
   async getChainBalances(chain, accountIndex = 0) {
     const config = this._normalizedChains.get(chain);
     if (!config) {
-      throw new ChainError(
-        2001 /* CHAIN_NOT_CONFIGURED */,
-        `Chain "${chain}" not configured`,
-        { chain }
-      );
+      throw new ChainError(2001 /* CHAIN_NOT_CONFIGURED */, `Chain "${chain}" not configured`, {
+        chain
+      });
     }
     try {
       const signer = await this.getSigner(chain, accountIndex);
@@ -1947,7 +1952,10 @@ var _T402WDK = class _T402WDK {
       throw new BalanceError(
         5001 /* BALANCE_FETCH_FAILED */,
         `Failed to find best chain for payment: ${error instanceof Error ? error.message : String(error)}`,
-        { cause: error instanceof Error ? error : void 0, context: { amount: amount.toString() } }
+        {
+          cause: error instanceof Error ? error : void 0,
+          context: { amount: amount.toString() }
+        }
       );
     }
   }
@@ -1969,25 +1977,23 @@ var _T402WDK = class _T402WDK {
       );
     }
     if (!params.fromChain || !params.toChain) {
-      throw new BridgeError(
-        7003 /* BRIDGE_FAILED */,
-        "Both fromChain and toChain are required",
-        { fromChain: params.fromChain, toChain: params.toChain }
-      );
+      throw new BridgeError(7003 /* BRIDGE_FAILED */, "Both fromChain and toChain are required", {
+        fromChain: params.fromChain,
+        toChain: params.toChain
+      });
     }
     if (params.fromChain === params.toChain) {
-      throw new BridgeError(
-        7002 /* BRIDGE_NOT_SUPPORTED */,
-        "Cannot bridge to the same chain",
-        { fromChain: params.fromChain, toChain: params.toChain }
-      );
+      throw new BridgeError(7002 /* BRIDGE_NOT_SUPPORTED */, "Cannot bridge to the same chain", {
+        fromChain: params.fromChain,
+        toChain: params.toChain
+      });
     }
     if (!params.amount || params.amount <= 0n) {
-      throw new BridgeError(
-        7003 /* BRIDGE_FAILED */,
-        "Amount must be greater than 0",
-        { fromChain: params.fromChain, toChain: params.toChain, context: { amount: params.amount?.toString() } }
-      );
+      throw new BridgeError(7003 /* BRIDGE_FAILED */, "Amount must be greater than 0", {
+        fromChain: params.fromChain,
+        toChain: params.toChain,
+        context: { amount: params.amount?.toString() }
+      });
     }
     if (!this.canBridge(params.fromChain, params.toChain)) {
       throw new BridgeError(
@@ -2116,11 +2122,6 @@ var _T402WDK = class _T402WDK {
     this._signerCache.clear();
   }
 };
-// WDK module references (set via registerWDK)
-_T402WDK._WDK = null;
-_T402WDK._WalletManagerEvm = null;
-_T402WDK._BridgeUsdt0Evm = null;
-var T402WDK = _T402WDK;
 function formatTokenAmount(amount, decimals) {
   if (amount === 0n) {
     return "0";
@@ -2139,26 +2140,24 @@ function formatTokenAmount(amount, decimals) {
 // src/bridge.ts
 var import_evm2 = require("@t402/evm");
 var WdkBridge = class {
-  constructor() {
-    this.bridges = /* @__PURE__ */ new Map();
-  }
+  bridges = /* @__PURE__ */ new Map();
   /**
    * Create bridge signer adapter from WDK signer
    */
   createBridgeSigner(signer) {
     return {
       address: signer.address,
-      readContract: async (args) => {
+      readContract: async (_args) => {
         throw new Error(
           "readContract not available on WDKSigner. Use T402WDK.bridgeUsdt0() instead."
         );
       },
-      writeContract: async (args) => {
+      writeContract: async (_args) => {
         throw new Error(
           "writeContract not available on WDKSigner. Use T402WDK.bridgeUsdt0() instead."
         );
       },
-      waitForTransactionReceipt: async (args) => {
+      waitForTransactionReceipt: async (_args) => {
         throw new Error(
           "waitForTransactionReceipt not available on WDKSigner. Use T402WDK.bridgeUsdt0() instead."
         );
@@ -2203,6 +2202,629 @@ function createDirectBridge(signer, chain) {
 
 // src/index.ts
 var import_evm3 = require("@t402/evm");
+
+// src/hardware/types.ts
+var HardwareWalletErrorCode = /* @__PURE__ */ ((HardwareWalletErrorCode2) => {
+  HardwareWalletErrorCode2["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
+  HardwareWalletErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+  HardwareWalletErrorCode2["DEVICE_LOCKED"] = "DEVICE_LOCKED";
+  HardwareWalletErrorCode2["APP_NOT_OPEN"] = "APP_NOT_OPEN";
+  HardwareWalletErrorCode2["TRANSPORT_ERROR"] = "TRANSPORT_ERROR";
+  HardwareWalletErrorCode2["USER_REJECTED"] = "USER_REJECTED";
+  HardwareWalletErrorCode2["SIGNING_FAILED"] = "SIGNING_FAILED";
+  HardwareWalletErrorCode2["INVALID_DATA"] = "INVALID_DATA";
+  HardwareWalletErrorCode2["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+  HardwareWalletErrorCode2["TIMEOUT"] = "TIMEOUT";
+  HardwareWalletErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return HardwareWalletErrorCode2;
+})(HardwareWalletErrorCode || {});
+var HardwareWalletError = class extends Error {
+  code;
+  walletType;
+  cause;
+  constructor(code, message, walletType, cause) {
+    super(message);
+    this.name = "HardwareWalletError";
+    this.code = code;
+    this.walletType = walletType;
+    this.cause = cause;
+  }
+};
+
+// src/hardware/ledger.ts
+var DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0";
+var LedgerSigner = class {
+  walletType = "ledger";
+  _address = null;
+  _transport = null;
+  _eth = null;
+  _options;
+  _status = "disconnected";
+  _deviceInfo;
+  constructor(options = {}) {
+    this._options = {
+      transport: options.transport ?? "webusb",
+      accountIndex: options.accountIndex ?? 0,
+      derivationPath: options.derivationPath ?? `${DEFAULT_DERIVATION_PATH}/${options.accountIndex ?? 0}`,
+      timeout: options.timeout ?? 3e4,
+      scrambleKey: options.scrambleKey ?? true,
+      appName: options.appName ?? "Ethereum"
+    };
+    this._deviceInfo = {
+      type: "ledger",
+      isLocked: true,
+      status: "disconnected"
+    };
+  }
+  /**
+   * Get the wallet address
+   */
+  get address() {
+    if (!this._address) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Ledger not connected. Call connect() first.",
+        "ledger"
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Get device info
+   */
+  get deviceInfo() {
+    return { ...this._deviceInfo };
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this._status === "ready" && this._transport !== null;
+  }
+  /**
+   * Get the derivation path
+   */
+  get derivationPath() {
+    return this._options.derivationPath;
+  }
+  /**
+   * Connect to the Ledger device
+   */
+  async connect() {
+    if (this.isConnected) {
+      return;
+    }
+    this._status = "connecting";
+    this._deviceInfo.status = "connecting";
+    try {
+      const TransportModule = await this._getTransportModule();
+      const EthModule = await import("@ledgerhq/hw-app-eth");
+      this._transport = await TransportModule.default.create();
+      this._status = "connected";
+      this._deviceInfo.status = "connected";
+      this._eth = new EthModule.default(this._transport);
+      try {
+        const appConfig = await this._eth.getAppConfiguration();
+        this._deviceInfo.firmwareVersion = appConfig.version;
+      } catch {
+      }
+      const result = await this._eth.getAddress(this._options.derivationPath, false);
+      this._address = result.address;
+      this._status = "ready";
+      this._deviceInfo.status = "ready";
+      this._deviceInfo.isLocked = false;
+    } catch (error) {
+      this._status = "disconnected";
+      this._deviceInfo.status = "disconnected";
+      this._transport = null;
+      this._eth = null;
+      throw this._wrapError(error);
+    }
+  }
+  /**
+   * Disconnect from the Ledger device
+   */
+  async disconnect() {
+    if (this._transport) {
+      try {
+        await this._transport.close();
+      } catch {
+      }
+    }
+    this._transport = null;
+    this._eth = null;
+    this._address = null;
+    this._status = "disconnected";
+    this._deviceInfo.status = "disconnected";
+    this._deviceInfo.isLocked = true;
+  }
+  /**
+   * Sign EIP-712 typed data
+   *
+   * Note: Requires Ethereum app version 1.6.0+ for EIP-712 support
+   */
+  async signTypedData(params) {
+    if (!this.isConnected || !this._eth) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Ledger not connected",
+        "ledger"
+      );
+    }
+    try {
+      const result = await this._eth.signEIP712Message(this._options.derivationPath, {
+        domain: params.domain,
+        types: params.types,
+        primaryType: params.primaryType,
+        message: params.message
+      });
+      const r = result.r.padStart(64, "0");
+      const s = result.s.padStart(64, "0");
+      const v = result.v.toString(16).padStart(2, "0");
+      return `0x${r}${s}${v}`;
+    } catch (error) {
+      throw this._wrapError(error);
+    }
+  }
+  /**
+   * Sign a personal message
+   */
+  async signMessage(message) {
+    if (!this.isConnected || !this._eth) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Ledger not connected",
+        "ledger"
+      );
+    }
+    try {
+      const messageHex = typeof message === "string" ? Buffer.from(message).toString("hex") : Buffer.from(message).toString("hex");
+      const result = await this._eth.signPersonalMessage(this._options.derivationPath, messageHex);
+      const r = result.r.padStart(64, "0");
+      const s = result.s.padStart(64, "0");
+      const v = result.v.toString(16).padStart(2, "0");
+      return `0x${r}${s}${v}`;
+    } catch (error) {
+      throw this._wrapError(error);
+    }
+  }
+  /**
+   * Get multiple addresses for account selection
+   */
+  async getAddresses(count = 5, startIndex = 0) {
+    if (!this.isConnected || !this._eth) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Ledger not connected",
+        "ledger"
+      );
+    }
+    const addresses = [];
+    for (let i = startIndex; i < startIndex + count; i++) {
+      const path = `${DEFAULT_DERIVATION_PATH}/${i}`;
+      const result = await this._eth.getAddress(path, false);
+      addresses.push(result.address);
+    }
+    return addresses;
+  }
+  /**
+   * Get the appropriate transport module based on options
+   */
+  async _getTransportModule() {
+    switch (this._options.transport) {
+      case "webhid":
+        return import("@ledgerhq/hw-transport-webhid");
+      case "bluetooth":
+        return import("@ledgerhq/hw-transport-web-ble");
+      case "webusb":
+      default:
+        return import("@ledgerhq/hw-transport-webusb");
+    }
+  }
+  /**
+   * Wrap errors in HardwareWalletError
+   */
+  _wrapError(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const message = err.message.toLowerCase();
+    if (message.includes("denied") || message.includes("rejected")) {
+      return new HardwareWalletError(
+        "USER_REJECTED" /* USER_REJECTED */,
+        "User rejected the action on the Ledger device",
+        "ledger",
+        err
+      );
+    }
+    if (message.includes("locked")) {
+      return new HardwareWalletError(
+        "DEVICE_LOCKED" /* DEVICE_LOCKED */,
+        "Ledger device is locked. Please unlock it.",
+        "ledger",
+        err
+      );
+    }
+    if (message.includes("no device") || message.includes("not found")) {
+      return new HardwareWalletError(
+        "DEVICE_NOT_FOUND" /* DEVICE_NOT_FOUND */,
+        "Ledger device not found. Please connect your device.",
+        "ledger",
+        err
+      );
+    }
+    if (message.includes("app") || message.includes("ethereum")) {
+      return new HardwareWalletError(
+        "APP_NOT_OPEN" /* APP_NOT_OPEN */,
+        "Please open the Ethereum app on your Ledger device.",
+        "ledger",
+        err
+      );
+    }
+    if (message.includes("timeout")) {
+      return new HardwareWalletError(
+        "TIMEOUT" /* TIMEOUT */,
+        "Connection timed out",
+        "ledger",
+        err
+      );
+    }
+    return new HardwareWalletError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      err.message,
+      "ledger",
+      err
+    );
+  }
+};
+async function createLedgerSigner(options) {
+  const signer = new LedgerSigner(options);
+  await signer.connect();
+  return signer;
+}
+
+// src/hardware/trezor.ts
+var DEFAULT_DERIVATION_PATH2 = "m/44'/60'/0'/0";
+var TrezorConnect = null;
+var TrezorSigner = class {
+  walletType = "trezor";
+  _address = null;
+  _options;
+  _status = "disconnected";
+  _deviceInfo;
+  _initialized = false;
+  constructor(options) {
+    if (!options.manifest) {
+      throw new HardwareWalletError(
+        "INVALID_DATA" /* INVALID_DATA */,
+        "Trezor manifest is required (email and appUrl)",
+        "trezor"
+      );
+    }
+    this._options = {
+      manifest: options.manifest,
+      transport: options.transport ?? "webusb",
+      accountIndex: options.accountIndex ?? 0,
+      derivationPath: options.derivationPath ?? `${DEFAULT_DERIVATION_PATH2}/${options.accountIndex ?? 0}`,
+      timeout: options.timeout ?? 3e4,
+      popup: options.popup ?? true,
+      debug: options.debug ?? false
+    };
+    this._deviceInfo = {
+      type: "trezor",
+      isLocked: true,
+      status: "disconnected"
+    };
+  }
+  /**
+   * Get the wallet address
+   */
+  get address() {
+    if (!this._address) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Trezor not connected. Call connect() first.",
+        "trezor"
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Get device info
+   */
+  get deviceInfo() {
+    return { ...this._deviceInfo };
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this._status === "ready" && this._address !== null;
+  }
+  /**
+   * Get the derivation path
+   */
+  get derivationPath() {
+    return this._options.derivationPath;
+  }
+  /**
+   * Initialize Trezor Connect
+   */
+  async _initTrezorConnect() {
+    if (this._initialized && TrezorConnect) {
+      return;
+    }
+    try {
+      const module2 = await import("@trezor/connect");
+      TrezorConnect = module2.default;
+      await TrezorConnect.init({
+        manifest: {
+          email: this._options.manifest.email,
+          appUrl: this._options.manifest.appUrl,
+          appName: "T402 WDK"
+        },
+        popup: this._options.popup,
+        debug: this._options.debug
+      });
+      this._initialized = true;
+    } catch (error) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        `Failed to initialize Trezor Connect: ${error instanceof Error ? error.message : String(error)}`,
+        "trezor",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Connect to the Trezor device
+   */
+  async connect() {
+    if (this.isConnected) {
+      return;
+    }
+    this._status = "connecting";
+    this._deviceInfo.status = "connecting";
+    try {
+      await this._initTrezorConnect();
+      if (!TrezorConnect) {
+        throw new Error("TrezorConnect not initialized");
+      }
+      const featuresResult = await TrezorConnect.getFeatures();
+      if (featuresResult.success) {
+        const features = featuresResult.payload;
+        this._deviceInfo.model = features.model;
+        this._deviceInfo.firmwareVersion = `${features.major_version}.${features.minor_version}.${features.patch_version}`;
+      }
+      const result = await TrezorConnect.ethereumGetAddress({
+        path: this._options.derivationPath,
+        showOnTrezor: false
+      });
+      if (!result.success) {
+        throw new Error(result.payload.error || "Failed to get address");
+      }
+      this._address = result.payload.address;
+      this._status = "ready";
+      this._deviceInfo.status = "ready";
+      this._deviceInfo.isLocked = false;
+    } catch (error) {
+      this._status = "disconnected";
+      this._deviceInfo.status = "disconnected";
+      this._address = null;
+      throw this._wrapError(error);
+    }
+  }
+  /**
+   * Disconnect from the Trezor device
+   */
+  async disconnect() {
+    if (TrezorConnect) {
+      try {
+        TrezorConnect.dispose();
+      } catch {
+      }
+    }
+    this._address = null;
+    this._status = "disconnected";
+    this._deviceInfo.status = "disconnected";
+    this._deviceInfo.isLocked = true;
+    this._initialized = false;
+    TrezorConnect = null;
+  }
+  /**
+   * Sign EIP-712 typed data
+   */
+  async signTypedData(params) {
+    if (!this.isConnected) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Trezor not connected",
+        "trezor"
+      );
+    }
+    await this._initTrezorConnect();
+    if (!TrezorConnect) {
+      throw new Error("TrezorConnect not initialized");
+    }
+    try {
+      const trezorTypes = this._convertTypesToTrezorFormat(params.types);
+      if (!trezorTypes.EIP712Domain) {
+        trezorTypes.EIP712Domain = [
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" }
+        ];
+      }
+      const result = await TrezorConnect.ethereumSignTypedData({
+        path: this._options.derivationPath,
+        data: {
+          domain: params.domain,
+          types: trezorTypes,
+          primaryType: params.primaryType,
+          message: params.message
+        },
+        metamask_v4_compat: true
+      });
+      if (!result.success) {
+        throw new Error(result.payload.error || "Failed to sign typed data");
+      }
+      return result.payload.signature;
+    } catch (error) {
+      throw this._wrapError(error);
+    }
+  }
+  /**
+   * Sign a personal message
+   */
+  async signMessage(message) {
+    if (!this.isConnected) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Trezor not connected",
+        "trezor"
+      );
+    }
+    await this._initTrezorConnect();
+    if (!TrezorConnect) {
+      throw new Error("TrezorConnect not initialized");
+    }
+    try {
+      const messageHex = typeof message === "string" ? `0x${Buffer.from(message).toString("hex")}` : `0x${Buffer.from(message).toString("hex")}`;
+      const result = await TrezorConnect.ethereumSignMessage({
+        path: this._options.derivationPath,
+        message: messageHex,
+        hex: true
+      });
+      if (!result.success) {
+        throw new Error(result.payload.error || "Failed to sign message");
+      }
+      return `0x${result.payload.signature}`;
+    } catch (error) {
+      throw this._wrapError(error);
+    }
+  }
+  /**
+   * Get multiple addresses for account selection
+   */
+  async getAddresses(count = 5, startIndex = 0) {
+    if (!this.isConnected) {
+      throw new HardwareWalletError(
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        "Trezor not connected",
+        "trezor"
+      );
+    }
+    await this._initTrezorConnect();
+    if (!TrezorConnect) {
+      throw new Error("TrezorConnect not initialized");
+    }
+    const addresses = [];
+    const bundle = [];
+    for (let i = startIndex; i < startIndex + count; i++) {
+      bundle.push({
+        path: `${DEFAULT_DERIVATION_PATH2}/${i}`,
+        showOnTrezor: false
+      });
+    }
+    const result = await TrezorConnect.ethereumGetAddress({ bundle });
+    if (!result.success) {
+      throw this._wrapError(new Error(result.payload.error || "Failed to get addresses"));
+    }
+    for (const item of result.payload) {
+      addresses.push(item.address);
+    }
+    return addresses;
+  }
+  /**
+   * Convert EIP-712 types to Trezor format
+   */
+  _convertTypesToTrezorFormat(types) {
+    const result = {};
+    for (const [typeName, fields] of Object.entries(types)) {
+      if (Array.isArray(fields)) {
+        result[typeName] = fields.map((field) => ({
+          name: String(field.name),
+          type: String(field.type)
+        }));
+      }
+    }
+    return result;
+  }
+  /**
+   * Wrap errors in HardwareWalletError
+   */
+  _wrapError(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const message = err.message.toLowerCase();
+    if (message.includes("cancelled") || message.includes("rejected") || message.includes("denied")) {
+      return new HardwareWalletError(
+        "USER_REJECTED" /* USER_REJECTED */,
+        "User cancelled the action on the Trezor device",
+        "trezor",
+        err
+      );
+    }
+    if (message.includes("pin")) {
+      return new HardwareWalletError(
+        "DEVICE_LOCKED" /* DEVICE_LOCKED */,
+        "Trezor device requires PIN entry",
+        "trezor",
+        err
+      );
+    }
+    if (message.includes("passphrase")) {
+      return new HardwareWalletError(
+        "DEVICE_LOCKED" /* DEVICE_LOCKED */,
+        "Trezor device requires passphrase entry",
+        "trezor",
+        err
+      );
+    }
+    if (message.includes("device") && message.includes("not found")) {
+      return new HardwareWalletError(
+        "DEVICE_NOT_FOUND" /* DEVICE_NOT_FOUND */,
+        "Trezor device not found. Please connect your device.",
+        "trezor",
+        err
+      );
+    }
+    if (message.includes("timeout")) {
+      return new HardwareWalletError(
+        "TIMEOUT" /* TIMEOUT */,
+        "Connection timed out",
+        "trezor",
+        err
+      );
+    }
+    return new HardwareWalletError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      err.message,
+      "trezor",
+      err
+    );
+  }
+};
+async function createTrezorSigner(options) {
+  const signer = new TrezorSigner(options);
+  await signer.connect();
+  return signer;
+}
+
+// src/hardware/index.ts
+function detectHardwareWalletSupport() {
+  const hasNavigator = typeof navigator !== "undefined";
+  return {
+    ledger: {
+      webusb: hasNavigator && "usb" in navigator,
+      webhid: hasNavigator && "hid" in navigator,
+      bluetooth: hasNavigator && "bluetooth" in navigator
+    },
+    trezor: hasNavigator && "usb" in navigator
+  };
+}
+function isHardwareWalletSupported() {
+  const support = detectHardwareWalletSupport();
+  return support.ledger.webusb || support.ledger.webhid || support.ledger.bluetooth || support.trezor;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BalanceCache,
@@ -2215,7 +2837,10 @@ var import_evm3 = require("@t402/evm");
   DEFAULT_CHAINS,
   DEFAULT_RETRY_CONFIG,
   DEFAULT_RPC_ENDPOINTS,
+  HardwareWalletError,
+  HardwareWalletErrorCode,
   LAYERZERO_ENDPOINT_IDS,
+  LedgerSigner,
   MockWDKSigner,
   RPCError,
   SignerError,
@@ -2223,6 +2848,7 @@ var import_evm3 = require("@t402/evm");
   T402WDK,
   TTLCache,
   TransactionError,
+  TrezorSigner,
   USDC_ADDRESSES,
   USDT0_ADDRESSES,
   USDT0_OFT_ADDRESSES,
@@ -2234,7 +2860,10 @@ var import_evm3 = require("@t402/evm");
   WDKSigner,
   WdkBridge,
   createDirectBridge,
+  createLedgerSigner,
+  createTrezorSigner,
   createWDKSigner,
+  detectHardwareWalletSupport,
   getBridgeableChains,
   getChainFromNetwork,
   getChainId,
@@ -2242,6 +2871,7 @@ var import_evm3 = require("@t402/evm");
   getPreferredToken,
   getUsdt0Chains,
   hasErrorCode,
+  isHardwareWalletSupported,
   isWDKError,
   normalizeChainConfig,
   supportsBridging,