@t402/wdk 2.0.0

package/dist/esm/index.mjs

@@ -0,0 +1,2193 @@
+// src/cache.ts
+var DEFAULT_CACHE_CONFIG = {
+  defaultTTL: 3e4,
+  // 30 seconds
+  maxSize: 1e3,
+  refreshOnAccess: false
+};
+var TTLCache = class {
+  constructor(config = {}) {
+    this._cache = /* @__PURE__ */ new Map();
+    this._cleanupInterval = null;
+    this._config = { ...DEFAULT_CACHE_CONFIG, ...config };
+    if (this._config.maxSize > 0) {
+      this._startCleanup();
+    }
+  }
+  /**
+   * Get a value from the cache
+   *
+   * @param key - Cache key
+   * @returns The cached value or undefined if not found/expired
+   */
+  get(key) {
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this._cache.delete(key);
+      return void 0;
+    }
+    if (this._config.refreshOnAccess) {
+      entry.expiresAt = Date.now() + this._config.defaultTTL;
+    }
+    return entry.value;
+  }
+  /**
+   * Set a value in the cache
+   *
+   * @param key - Cache key
+   * @param value - Value to cache
+   * @param ttl - TTL in milliseconds (optional, uses default if not provided)
+   */
+  set(key, value, ttl) {
+    if (this._cache.size >= this._config.maxSize) {
+      this._evictOldest();
+    }
+    const expiresAt = Date.now() + (ttl ?? this._config.defaultTTL);
+    this._cache.set(key, { value, expiresAt });
+  }
+  /**
+   * Check if a key exists and is not expired
+   *
+   * @param key - Cache key
+   * @returns true if key exists and is not expired
+   */
+  has(key) {
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this._cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete a key from the cache
+   *
+   * @param key - Cache key
+   * @returns true if key was deleted
+   */
+  delete(key) {
+    return this._cache.delete(key);
+  }
+  /**
+   * Delete all keys matching a prefix
+   *
+   * @param prefix - Key prefix to match
+   * @returns Number of keys deleted
+   */
+  deleteByPrefix(prefix) {
+    let count = 0;
+    for (const key of this._cache.keys()) {
+      if (key.startsWith(prefix)) {
+        this._cache.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  clear() {
+    this._cache.clear();
+  }
+  /**
+   * Get the number of entries in the cache (including expired)
+   */
+  get size() {
+    return this._cache.size;
+  }
+  /**
+   * Get the number of valid (non-expired) entries
+   */
+  get validSize() {
+    const now = Date.now();
+    let count = 0;
+    for (const entry of this._cache.values()) {
+      if (now <= entry.expiresAt) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Get all valid keys
+   */
+  keys() {
+    const now = Date.now();
+    const validKeys = [];
+    for (const [key, entry] of this._cache.entries()) {
+      if (now <= entry.expiresAt) {
+        validKeys.push(key);
+      }
+    }
+    return validKeys;
+  }
+  /**
+   * Get remaining TTL for a key in milliseconds
+   *
+   * @param key - Cache key
+   * @returns Remaining TTL in ms, or -1 if not found/expired
+   */
+  getTTL(key) {
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return -1;
+    }
+    const remaining = entry.expiresAt - Date.now();
+    if (remaining <= 0) {
+      this._cache.delete(key);
+      return -1;
+    }
+    return remaining;
+  }
+  /**
+   * Update TTL for an existing key
+   *
+   * @param key - Cache key
+   * @param ttl - New TTL in milliseconds
+   * @returns true if key exists and TTL was updated
+   */
+  touch(key, ttl) {
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this._cache.delete(key);
+      return false;
+    }
+    entry.expiresAt = Date.now() + (ttl ?? this._config.defaultTTL);
+    return true;
+  }
+  /**
+   * Get or set a value using a factory function
+   *
+   * @param key - Cache key
+   * @param factory - Function to create value if not cached
+   * @param ttl - TTL in milliseconds (optional)
+   * @returns The cached or newly created value
+   */
+  async getOrSet(key, factory, ttl) {
+    const cached = this.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const value = await factory();
+    this.set(key, value, ttl);
+    return value;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const now = Date.now();
+    let validCount = 0;
+    let expiredCount = 0;
+    let oldestExpiry = Infinity;
+    let newestExpiry = 0;
+    for (const entry of this._cache.values()) {
+      if (now <= entry.expiresAt) {
+        validCount++;
+        if (entry.expiresAt < oldestExpiry) oldestExpiry = entry.expiresAt;
+        if (entry.expiresAt > newestExpiry) newestExpiry = entry.expiresAt;
+      } else {
+        expiredCount++;
+      }
+    }
+    return {
+      totalSize: this._cache.size,
+      validSize: validCount,
+      expiredSize: expiredCount,
+      maxSize: this._config.maxSize,
+      defaultTTL: this._config.defaultTTL,
+      oldestExpiryMs: oldestExpiry === Infinity ? 0 : oldestExpiry - now,
+      newestExpiryMs: newestExpiry === 0 ? 0 : newestExpiry - now
+    };
+  }
+  /**
+   * Stop the cleanup interval
+   */
+  dispose() {
+    if (this._cleanupInterval) {
+      clearInterval(this._cleanupInterval);
+      this._cleanupInterval = null;
+    }
+    this._cache.clear();
+  }
+  /**
+   * Start periodic cleanup of expired entries
+   */
+  _startCleanup() {
+    this._cleanupInterval = setInterval(() => {
+      this._removeExpired();
+    }, 6e4);
+    if (this._cleanupInterval.unref) {
+      this._cleanupInterval.unref();
+    }
+  }
+  /**
+   * Remove all expired entries
+   */
+  _removeExpired() {
+    const now = Date.now();
+    let count = 0;
+    for (const [key, entry] of this._cache.entries()) {
+      if (now > entry.expiresAt) {
+        this._cache.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Evict oldest entries to make room
+   */
+  _evictOldest() {
+    this._removeExpired();
+    if (this._cache.size >= this._config.maxSize) {
+      let oldestKey = null;
+      let oldestExpiry = Infinity;
+      for (const [key, entry] of this._cache.entries()) {
+        if (entry.expiresAt < oldestExpiry) {
+          oldestExpiry = entry.expiresAt;
+          oldestKey = key;
+        }
+      }
+      if (oldestKey) {
+        this._cache.delete(oldestKey);
+      }
+    }
+  }
+};
+var DEFAULT_BALANCE_CACHE_CONFIG = {
+  enabled: true,
+  nativeBalanceTTL: 15e3,
+  // 15 seconds
+  tokenBalanceTTL: 3e4,
+  // 30 seconds
+  aggregatedBalanceTTL: 6e4,
+  // 60 seconds
+  maxSize: 500
+};
+var BalanceCache = class {
+  constructor(config = {}) {
+    this._config = { ...DEFAULT_BALANCE_CACHE_CONFIG, ...config };
+    this._cache = new TTLCache({
+      defaultTTL: this._config.tokenBalanceTTL,
+      maxSize: this._config.maxSize
+    });
+    this._aggregatedCache = new TTLCache({
+      defaultTTL: this._config.aggregatedBalanceTTL,
+      maxSize: 100
+      // Fewer aggregated balance entries
+    });
+  }
+  /**
+   * Check if caching is enabled
+   */
+  get enabled() {
+    return this._config.enabled;
+  }
+  /**
+   * Get cache configuration
+   */
+  get config() {
+    return { ...this._config };
+  }
+  // ========== Native Balance Methods ==========
+  /**
+   * Get cached native balance
+   */
+  getNativeBalance(chain, address) {
+    if (!this._config.enabled) return void 0;
+    return this._cache.get(this._nativeKey(chain, address));
+  }
+  /**
+   * Set native balance in cache
+   */
+  setNativeBalance(chain, address, balance) {
+    if (!this._config.enabled) return;
+    this._cache.set(this._nativeKey(chain, address), balance, this._config.nativeBalanceTTL);
+  }
+  /**
+   * Get or fetch native balance
+   */
+  async getOrFetchNativeBalance(chain, address, fetcher) {
+    if (!this._config.enabled) {
+      return fetcher();
+    }
+    return this._cache.getOrSet(
+      this._nativeKey(chain, address),
+      fetcher,
+      this._config.nativeBalanceTTL
+    );
+  }
+  // ========== Token Balance Methods ==========
+  /**
+   * Get cached token balance
+   */
+  getTokenBalance(chain, token, address) {
+    if (!this._config.enabled) return void 0;
+    return this._cache.get(this._tokenKey(chain, token, address));
+  }
+  /**
+   * Set token balance in cache
+   */
+  setTokenBalance(chain, token, address, balance) {
+    if (!this._config.enabled) return;
+    this._cache.set(this._tokenKey(chain, token, address), balance, this._config.tokenBalanceTTL);
+  }
+  /**
+   * Get or fetch token balance
+   */
+  async getOrFetchTokenBalance(chain, token, address, fetcher) {
+    if (!this._config.enabled) {
+      return fetcher();
+    }
+    return this._cache.getOrSet(
+      this._tokenKey(chain, token, address),
+      fetcher,
+      this._config.tokenBalanceTTL
+    );
+  }
+  // ========== Aggregated Balance Methods ==========
+  /**
+   * Get cached aggregated balance
+   */
+  getAggregatedBalance(key) {
+    if (!this._config.enabled) return void 0;
+    return this._aggregatedCache.get(this._aggregatedKey(key));
+  }
+  /**
+   * Set aggregated balance in cache
+   */
+  setAggregatedBalance(key, value) {
+    if (!this._config.enabled) return;
+    this._aggregatedCache.set(this._aggregatedKey(key), value, this._config.aggregatedBalanceTTL);
+  }
+  /**
+   * Get or fetch aggregated balance
+   */
+  async getOrFetchAggregatedBalance(key, fetcher) {
+    if (!this._config.enabled) {
+      return fetcher();
+    }
+    return this._aggregatedCache.getOrSet(
+      this._aggregatedKey(key),
+      fetcher,
+      this._config.aggregatedBalanceTTL
+    );
+  }
+  // ========== Cache Management ==========
+  /**
+   * Invalidate all balances for a chain
+   */
+  invalidateChain(chain) {
+    const count1 = this._cache.deleteByPrefix(`native:${chain}:`);
+    const count2 = this._cache.deleteByPrefix(`token:${chain}:`);
+    const count3 = this._aggregatedCache.deleteByPrefix(`agg:`);
+    return count1 + count2 + count3;
+  }
+  /**
+   * Invalidate all balances for an address
+   */
+  invalidateAddress(address) {
+    let count = 0;
+    const lowerAddress = address.toLowerCase();
+    for (const key of this._cache.keys()) {
+      if (key.toLowerCase().includes(lowerAddress)) {
+        this._cache.delete(key);
+        count++;
+      }
+    }
+    this._aggregatedCache.clear();
+    return count;
+  }
+  /**
+   * Invalidate specific token balance
+   */
+  invalidateTokenBalance(chain, token, address) {
+    return this._cache.delete(this._tokenKey(chain, token, address));
+  }
+  /**
+   * Clear all caches
+   */
+  clear() {
+    this._cache.clear();
+    this._aggregatedCache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      balanceCache: this._cache.getStats(),
+      aggregatedCache: this._aggregatedCache.getStats(),
+      config: this.config
+    };
+  }
+  /**
+   * Dispose of cache resources
+   */
+  dispose() {
+    this._cache.dispose();
+    this._aggregatedCache.dispose();
+  }
+  // ========== Private Key Generators ==========
+  _nativeKey(chain, address) {
+    return `native:${chain}:${address.toLowerCase()}`;
+  }
+  _tokenKey(chain, token, address) {
+    return `token:${chain}:${token.toLowerCase()}:${address.toLowerCase()}`;
+  }
+  _aggregatedKey(key) {
+    return `agg:${key}`;
+  }
+};
+
+// src/chains.ts
+var DEFAULT_CHAINS = {
+  ethereum: {
+    chainId: 1,
+    network: "eip155:1",
+    name: "ethereum"
+  },
+  arbitrum: {
+    chainId: 42161,
+    network: "eip155:42161",
+    name: "arbitrum"
+  },
+  base: {
+    chainId: 8453,
+    network: "eip155:8453",
+    name: "base"
+  },
+  ink: {
+    chainId: 57073,
+    network: "eip155:57073",
+    name: "ink"
+  },
+  berachain: {
+    chainId: 80094,
+    network: "eip155:80094",
+    name: "berachain"
+  },
+  unichain: {
+    chainId: 130,
+    network: "eip155:130",
+    name: "unichain"
+  },
+  polygon: {
+    chainId: 137,
+    network: "eip155:137",
+    name: "polygon"
+  }
+};
+var DEFAULT_RPC_ENDPOINTS = {
+  ethereum: "https://eth.drpc.org",
+  arbitrum: "https://arb1.arbitrum.io/rpc",
+  base: "https://mainnet.base.org",
+  ink: "https://rpc-gel.inkonchain.com",
+  polygon: "https://polygon-rpc.com"
+};
+var USDT0_ADDRESSES = {
+  ethereum: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+  arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  ink: "0x0200C29006150606B650577BBE7B6248F58470c1",
+  berachain: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  unichain: "0x588ce4F028D8e7B53B687865d6A67b3A54C75518"
+};
+var USDC_ADDRESSES = {
+  ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  polygon: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+};
+var USDT_LEGACY_ADDRESSES = {
+  ethereum: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  polygon: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
+};
+var CHAIN_TOKENS = {
+  ethereum: [
+    {
+      address: USDT0_ADDRESSES.ethereum,
+      symbol: "USDT0",
+      name: "TetherToken",
+      decimals: 6,
+      supportsEIP3009: true
+    },
+    {
+      address: USDC_ADDRESSES.ethereum,
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      supportsEIP3009: true
+    },
+    {
+      address: USDT_LEGACY_ADDRESSES.ethereum,
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 6,
+      supportsEIP3009: false
+    }
+  ],
+  arbitrum: [
+    {
+      address: USDT0_ADDRESSES.arbitrum,
+      symbol: "USDT0",
+      name: "TetherToken",
+      decimals: 6,
+      supportsEIP3009: true
+    },
+    {
+      address: USDC_ADDRESSES.arbitrum,
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      supportsEIP3009: true
+    }
+  ],
+  base: [
+    {
+      address: USDC_ADDRESSES.base,
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      supportsEIP3009: true
+    }
+  ],
+  ink: [
+    {
+      address: USDT0_ADDRESSES.ink,
+      symbol: "USDT0",
+      name: "TetherToken",
+      decimals: 6,
+      supportsEIP3009: true
+    }
+  ],
+  berachain: [
+    {
+      address: USDT0_ADDRESSES.berachain,
+      symbol: "USDT0",
+      name: "TetherToken",
+      decimals: 6,
+      supportsEIP3009: true
+    }
+  ],
+  unichain: [
+    {
+      address: USDT0_ADDRESSES.unichain,
+      symbol: "USDT0",
+      name: "TetherToken",
+      decimals: 6,
+      supportsEIP3009: true
+    }
+  ],
+  polygon: [
+    {
+      address: USDC_ADDRESSES.polygon,
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      supportsEIP3009: true
+    },
+    {
+      address: USDT_LEGACY_ADDRESSES.polygon,
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 6,
+      supportsEIP3009: false
+    }
+  ]
+};
+function normalizeChainConfig(chainName, config) {
+  const defaultConfig = DEFAULT_CHAINS[chainName];
+  if (typeof config === "string") {
+    return {
+      provider: config,
+      chainId: defaultConfig?.chainId ?? 1,
+      network: defaultConfig?.network ?? `eip155:1`,
+      name: chainName
+    };
+  }
+  return {
+    provider: config.provider,
+    chainId: config.chainId ?? defaultConfig?.chainId ?? 1,
+    network: config.network ?? defaultConfig?.network ?? `eip155:${config.chainId}`,
+    name: chainName
+  };
+}
+function getNetworkFromChain(chain) {
+  return DEFAULT_CHAINS[chain]?.network ?? `eip155:1`;
+}
+function getChainFromNetwork(network) {
+  for (const [chain, config] of Object.entries(DEFAULT_CHAINS)) {
+    if (config.network === network) {
+      return chain;
+    }
+  }
+  return void 0;
+}
+function getChainId(chain) {
+  return DEFAULT_CHAINS[chain]?.chainId ?? 1;
+}
+function getUsdt0Chains() {
+  return Object.keys(USDT0_ADDRESSES);
+}
+function getPreferredToken(chain) {
+  const tokens = CHAIN_TOKENS[chain];
+  if (!tokens || tokens.length === 0) return void 0;
+  return tokens.find((t) => t.symbol === "USDT0") ?? tokens.find((t) => t.symbol === "USDC") ?? tokens[0];
+}
+
+// src/errors.ts
+var WDKErrorCode = /* @__PURE__ */ ((WDKErrorCode2) => {
+  WDKErrorCode2[WDKErrorCode2["WDK_NOT_REGISTERED"] = 1001] = "WDK_NOT_REGISTERED";
+  WDKErrorCode2[WDKErrorCode2["WDK_NOT_INITIALIZED"] = 1002] = "WDK_NOT_INITIALIZED";
+  WDKErrorCode2[WDKErrorCode2["INVALID_SEED_PHRASE"] = 1003] = "INVALID_SEED_PHRASE";
+  WDKErrorCode2[WDKErrorCode2["WALLET_MANAGER_NOT_REGISTERED"] = 1004] = "WALLET_MANAGER_NOT_REGISTERED";
+  WDKErrorCode2[WDKErrorCode2["CHAIN_NOT_CONFIGURED"] = 2001] = "CHAIN_NOT_CONFIGURED";
+  WDKErrorCode2[WDKErrorCode2["CHAIN_NOT_SUPPORTED"] = 2002] = "CHAIN_NOT_SUPPORTED";
+  WDKErrorCode2[WDKErrorCode2["INVALID_CHAIN_CONFIG"] = 2003] = "INVALID_CHAIN_CONFIG";
+  WDKErrorCode2[WDKErrorCode2["UNKNOWN_CHAIN_ID"] = 2004] = "UNKNOWN_CHAIN_ID";
+  WDKErrorCode2[WDKErrorCode2["SIGNER_NOT_INITIALIZED"] = 3001] = "SIGNER_NOT_INITIALIZED";
+  WDKErrorCode2[WDKErrorCode2["ACCOUNT_FETCH_FAILED"] = 3002] = "ACCOUNT_FETCH_FAILED";
+  WDKErrorCode2[WDKErrorCode2["ADDRESS_FETCH_FAILED"] = 3003] = "ADDRESS_FETCH_FAILED";
+  WDKErrorCode2[WDKErrorCode2["SIGN_TYPED_DATA_FAILED"] = 4001] = "SIGN_TYPED_DATA_FAILED";
+  WDKErrorCode2[WDKErrorCode2["SIGN_MESSAGE_FAILED"] = 4002] = "SIGN_MESSAGE_FAILED";
+  WDKErrorCode2[WDKErrorCode2["INVALID_TYPED_DATA"] = 4003] = "INVALID_TYPED_DATA";
+  WDKErrorCode2[WDKErrorCode2["INVALID_MESSAGE"] = 4004] = "INVALID_MESSAGE";
+  WDKErrorCode2[WDKErrorCode2["USER_REJECTED_SIGNATURE"] = 4005] = "USER_REJECTED_SIGNATURE";
+  WDKErrorCode2[WDKErrorCode2["BALANCE_FETCH_FAILED"] = 5001] = "BALANCE_FETCH_FAILED";
+  WDKErrorCode2[WDKErrorCode2["TOKEN_BALANCE_FETCH_FAILED"] = 5002] = "TOKEN_BALANCE_FETCH_FAILED";
+  WDKErrorCode2[WDKErrorCode2["INVALID_TOKEN_ADDRESS"] = 5003] = "INVALID_TOKEN_ADDRESS";
+  WDKErrorCode2[WDKErrorCode2["TRANSACTION_FAILED"] = 6001] = "TRANSACTION_FAILED";
+  WDKErrorCode2[WDKErrorCode2["GAS_ESTIMATION_FAILED"] = 6002] = "GAS_ESTIMATION_FAILED";
+  WDKErrorCode2[WDKErrorCode2["INSUFFICIENT_BALANCE"] = 6003] = "INSUFFICIENT_BALANCE";
+  WDKErrorCode2[WDKErrorCode2["TRANSACTION_REVERTED"] = 6004] = "TRANSACTION_REVERTED";
+  WDKErrorCode2[WDKErrorCode2["TRANSACTION_TIMEOUT"] = 6005] = "TRANSACTION_TIMEOUT";
+  WDKErrorCode2[WDKErrorCode2["BRIDGE_NOT_AVAILABLE"] = 7001] = "BRIDGE_NOT_AVAILABLE";
+  WDKErrorCode2[WDKErrorCode2["BRIDGE_NOT_SUPPORTED"] = 7002] = "BRIDGE_NOT_SUPPORTED";
+  WDKErrorCode2[WDKErrorCode2["BRIDGE_FAILED"] = 7003] = "BRIDGE_FAILED";
+  WDKErrorCode2[WDKErrorCode2["INSUFFICIENT_BRIDGE_FEE"] = 7004] = "INSUFFICIENT_BRIDGE_FEE";
+  WDKErrorCode2[WDKErrorCode2["RPC_ERROR"] = 8001] = "RPC_ERROR";
+  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["UNKNOWN_ERROR"] = 9999] = "UNKNOWN_ERROR";
+  return WDKErrorCode2;
+})(WDKErrorCode || {});
+var WDKError = class _WDKError extends Error {
+  constructor(code, message, options) {
+    super(message);
+    this.name = "WDKError";
+    this.code = code;
+    this.cause = options?.cause;
+    this.context = options?.context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WDKError);
+    }
+  }
+  /**
+   * Create a JSON-serializable representation
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      cause: this.cause?.message,
+      stack: this.stack
+    };
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryable() {
+    return [
+      8002 /* RPC_TIMEOUT */,
+      8003 /* RPC_RATE_LIMITED */,
+      8004 /* RPC_CONNECTION_FAILED */,
+      5001 /* BALANCE_FETCH_FAILED */,
+      5002 /* TOKEN_BALANCE_FETCH_FAILED */,
+      6002 /* GAS_ESTIMATION_FAILED */
+    ].includes(this.code);
+  }
+};
+var WDKInitializationError = class extends WDKError {
+  constructor(message, options) {
+    super(1002 /* WDK_NOT_INITIALIZED */, message, options);
+    this.name = "WDKInitializationError";
+  }
+};
+var ChainError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options?.cause,
+      context: { ...options?.context, chain: options?.chain }
+    });
+    this.name = "ChainError";
+    this.chain = options?.chain;
+  }
+};
+var SignerError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options?.cause,
+      context: { ...options?.context, chain: options?.chain, address: options?.address }
+    });
+    this.name = "SignerError";
+    this.chain = options?.chain;
+    this.address = options?.address;
+  }
+};
+var SigningError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options.cause,
+      context: { ...options.context, operation: options.operation }
+    });
+    this.name = "SigningError";
+    this.operation = options.operation;
+  }
+};
+var BalanceError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options?.cause,
+      context: { ...options?.context, chain: options?.chain, token: options?.token }
+    });
+    this.name = "BalanceError";
+    this.chain = options?.chain;
+    this.token = options?.token;
+  }
+};
+var TransactionError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options?.cause,
+      context: { ...options?.context, chain: options?.chain, txHash: options?.txHash }
+    });
+    this.name = "TransactionError";
+    this.chain = options?.chain;
+    this.txHash = options?.txHash;
+  }
+};
+var BridgeError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options?.cause,
+      context: {
+        ...options?.context,
+        fromChain: options?.fromChain,
+        toChain: options?.toChain
+      }
+    });
+    this.name = "BridgeError";
+    this.fromChain = options?.fromChain;
+    this.toChain = options?.toChain;
+  }
+};
+var RPCError = class extends WDKError {
+  constructor(code, message, options) {
+    super(code, message, {
+      cause: options?.cause,
+      context: {
+        ...options?.context,
+        endpoint: options?.endpoint,
+        rpcCode: options?.rpcCode
+      }
+    });
+    this.name = "RPCError";
+    this.endpoint = options?.endpoint;
+    this.rpcCode = options?.rpcCode;
+  }
+};
+function wrapError(error, defaultCode = 9999 /* UNKNOWN_ERROR */, defaultMessage = "An unknown error occurred", context) {
+  if (error instanceof WDKError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    if (msg.includes("timeout") || msg.includes("timed out")) {
+      return new RPCError(8002 /* RPC_TIMEOUT */, `Request timeout: ${error.message}`, {
+        cause: error,
+        context
+      });
+    }
+    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 }
+      );
+    }
+    if (msg.includes("connection") || msg.includes("network") || msg.includes("econnrefused") || msg.includes("enotfound")) {
+      return new RPCError(
+        8004 /* RPC_CONNECTION_FAILED */,
+        `Connection failed: ${error.message}`,
+        { cause: error, context }
+      );
+    }
+    if (msg.includes("insufficient funds") || msg.includes("insufficient balance")) {
+      return new TransactionError(
+        6003 /* INSUFFICIENT_BALANCE */,
+        `Insufficient balance: ${error.message}`,
+        { cause: error, context }
+      );
+    }
+    if (msg.includes("user rejected") || msg.includes("user denied")) {
+      return new SigningError(
+        4005 /* USER_REJECTED_SIGNATURE */,
+        "User rejected the signature request",
+        { operation: "signTypedData", cause: error, context }
+      );
+    }
+    if (msg.includes("reverted") || msg.includes("revert")) {
+      return new TransactionError(
+        6004 /* TRANSACTION_REVERTED */,
+        `Transaction reverted: ${error.message}`,
+        { cause: error, context }
+      );
+    }
+    return new WDKError(defaultCode, error.message || defaultMessage, {
+      cause: error,
+      context
+    });
+  }
+  return new WDKError(defaultCode, String(error) || defaultMessage, { context });
+}
+function isWDKError(error) {
+  return error instanceof WDKError;
+}
+function hasErrorCode(error, code) {
+  return isWDKError(error) && error.code === code;
+}
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 1e4,
+  exponentialBackoff: true
+};
+async function withRetry(fn, config = {}) {
+  const { maxRetries, baseDelay, maxDelay, exponentialBackoff } = {
+    ...DEFAULT_RETRY_CONFIG,
+    ...config
+  };
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const wdkError = wrapError(error);
+      if (!wdkError.isRetryable() || attempt >= maxRetries) {
+        throw wdkError;
+      }
+      const delay = exponentialBackoff ? Math.min(baseDelay * Math.pow(2, attempt), maxDelay) : baseDelay;
+      const jitter = Math.random() * delay * 0.1;
+      await sleep(delay + jitter);
+    }
+  }
+  throw lastError ?? new Error("Retry failed with unknown error");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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`
+        )
+      );
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/signer.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_BALANCE_RETRY = {
+  maxRetries: 2,
+  baseDelay: 500
+};
+var WDKSigner = class {
+  /**
+   * Create a new WDK signer
+   *
+   * @param wdk - The WDK instance
+   * @param chain - Chain name (e.g., "arbitrum", "ethereum")
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @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 }
+      );
+    }
+    if (!chain || typeof chain !== "string") {
+      throw new SignerError(
+        2001 /* CHAIN_NOT_CONFIGURED */,
+        "Chain name is required and must be a string",
+        { chain }
+      );
+    }
+    if (accountIndex < 0 || !Number.isInteger(accountIndex)) {
+      throw new SignerError(
+        3001 /* SIGNER_NOT_INITIALIZED */,
+        "Account index must be a non-negative integer",
+        { chain, context: { accountIndex } }
+      );
+    }
+    this._wdk = wdk;
+    this._chain = chain;
+    this._accountIndex = accountIndex;
+    this._timeoutMs = timeoutMs;
+  }
+  /**
+   * Get the wallet address
+   * Throws if signer is not initialized
+   */
+  get address() {
+    if (!this._address) {
+      throw new SignerError(
+        3001 /* SIGNER_NOT_INITIALIZED */,
+        `Signer not initialized for chain "${this._chain}". Call initialize() first or use createWDKSigner() async factory.`,
+        { chain: this._chain }
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Check if the signer is initialized
+   */
+  get isInitialized() {
+    return this._account !== null && this._address !== null;
+  }
+  /**
+   * Initialize the signer by fetching the account
+   * Must be called before using the signer
+   *
+   * @throws {SignerError} If account fetch fails
+   */
+  async initialize() {
+    if (this._account) return;
+    try {
+      const accountPromise = this._wdk.getAccount(this._chain, this._accountIndex);
+      this._account = await withTimeout(
+        accountPromise,
+        this._timeoutMs,
+        `Fetching account for ${this._chain}`
+      );
+      const addressPromise = this._account.getAddress();
+      const addressString = await withTimeout(
+        addressPromise,
+        this._timeoutMs,
+        `Fetching address for ${this._chain}`
+      );
+      if (!addressString || !addressString.startsWith("0x")) {
+        throw new SignerError(
+          3003 /* ADDRESS_FETCH_FAILED */,
+          `Invalid address format received: ${addressString}`,
+          { chain: this._chain }
+        );
+      }
+      this._address = addressString;
+    } catch (error) {
+      this._account = null;
+      this._address = null;
+      if (error instanceof SignerError) {
+        throw error;
+      }
+      throw new SignerError(
+        3002 /* ACCOUNT_FETCH_FAILED */,
+        `Failed to initialize signer for chain "${this._chain}": ${error instanceof Error ? error.message : String(error)}`,
+        {
+          chain: this._chain,
+          cause: error instanceof Error ? error : void 0,
+          context: { accountIndex: this._accountIndex }
+        }
+      );
+    }
+  }
+  /**
+   * Get the underlying WDK account
+   * Initializes if not already done
+   *
+   * @throws {SignerError} If initialization fails
+   */
+  async getAccount() {
+    if (!this._account) {
+      await this.initialize();
+    }
+    return this._account;
+  }
+  /**
+   * Sign EIP-712 typed data for T402 payments
+   *
+   * This is the primary signing method used by T402 for EIP-3009
+   * transferWithAuthorization payments.
+   *
+   * @throws {SigningError} If signing fails
+   */
+  async signTypedData(message) {
+    if (!message || typeof message !== "object") {
+      throw new SigningError(
+        4003 /* INVALID_TYPED_DATA */,
+        "Invalid typed data: message object is required",
+        { operation: "signTypedData", context: { chain: this._chain } }
+      );
+    }
+    if (!message.domain || !message.types || !message.primaryType || !message.message) {
+      throw new SigningError(
+        4003 /* INVALID_TYPED_DATA */,
+        "Invalid typed data: domain, types, primaryType, and message are required",
+        {
+          operation: "signTypedData",
+          context: {
+            chain: this._chain,
+            hasFields: {
+              domain: !!message.domain,
+              types: !!message.types,
+              primaryType: !!message.primaryType,
+              message: !!message.message
+            }
+          }
+        }
+      );
+    }
+    try {
+      const account = await this.getAccount();
+      const signPromise = account.signTypedData({
+        domain: message.domain,
+        types: message.types,
+        primaryType: message.primaryType,
+        message: message.message
+      });
+      const signature = await withTimeout(
+        signPromise,
+        this._timeoutMs,
+        "Signing typed data"
+      );
+      if (!signature || !signature.startsWith("0x")) {
+        throw new SigningError(
+          4001 /* SIGN_TYPED_DATA_FAILED */,
+          `Invalid signature format received: ${signature?.substring(0, 10)}...`,
+          { operation: "signTypedData", context: { chain: this._chain } }
+        );
+      }
+      return signature;
+    } catch (error) {
+      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,
+        {
+          operation: "signTypedData",
+          cause: wrapped.cause,
+          context: wrapped.context
+        }
+      );
+    }
+  }
+  /**
+   * Sign a personal message
+   *
+   * @throws {SigningError} If signing fails
+   */
+  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 } }
+      );
+    }
+    if (typeof message !== "string" && !(message instanceof Uint8Array)) {
+      throw new SigningError(
+        4004 /* INVALID_MESSAGE */,
+        "Message must be a string or Uint8Array",
+        { operation: "signMessage", context: { chain: this._chain, type: typeof message } }
+      );
+    }
+    try {
+      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"
+      );
+      if (!signature || !signature.startsWith("0x")) {
+        throw new SigningError(
+          4002 /* SIGN_MESSAGE_FAILED */,
+          `Invalid signature format received: ${signature?.substring(0, 10)}...`,
+          { operation: "signMessage", context: { chain: this._chain } }
+        );
+      }
+      return signature;
+    } catch (error) {
+      if (error instanceof SigningError) {
+        throw error;
+      }
+      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
+        }
+      );
+    }
+  }
+  /**
+   * Get the chain name
+   */
+  getChain() {
+    return this._chain;
+  }
+  /**
+   * Get the chain ID
+   */
+  getChainId() {
+    return getChainId(this._chain);
+  }
+  /**
+   * Get the account index
+   */
+  getAccountIndex() {
+    return this._accountIndex;
+  }
+  /**
+   * Get native token balance (ETH, etc.)
+   *
+   * @throws {BalanceError} If balance fetch fails
+   */
+  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
+      );
+    } catch (error) {
+      if (error instanceof BalanceError) {
+        throw error;
+      }
+      throw new BalanceError(
+        5001 /* BALANCE_FETCH_FAILED */,
+        `Failed to get native balance for ${this._chain}: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          chain: this._chain,
+          cause: error instanceof Error ? error : void 0
+        }
+      );
+    }
+  }
+  /**
+   * Get ERC20 token balance
+   *
+   * @throws {BalanceError} If balance fetch fails
+   */
+  async getTokenBalance(tokenAddress) {
+    if (!tokenAddress || !tokenAddress.startsWith("0x")) {
+      throw new BalanceError(
+        5003 /* INVALID_TOKEN_ADDRESS */,
+        `Invalid token address: ${tokenAddress}`,
+        { chain: this._chain, token: tokenAddress }
+      );
+    }
+    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
+      );
+    } catch (error) {
+      if (error instanceof BalanceError) {
+        throw error;
+      }
+      throw new BalanceError(
+        5002 /* TOKEN_BALANCE_FETCH_FAILED */,
+        `Failed to get token balance for ${tokenAddress} on ${this._chain}: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          chain: this._chain,
+          token: tokenAddress,
+          cause: error instanceof Error ? error : void 0
+        }
+      );
+    }
+  }
+  /**
+   * Estimate gas for a transaction
+   *
+   * @throws {TransactionError} If gas estimation fails
+   */
+  async estimateGas(params) {
+    if (!params.to || !params.to.startsWith("0x")) {
+      throw new TransactionError(
+        6002 /* GAS_ESTIMATION_FAILED */,
+        `Invalid 'to' address: ${params.to}`,
+        { chain: this._chain, context: params }
+      );
+    }
+    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
+      );
+    } catch (error) {
+      if (error instanceof TransactionError) {
+        throw error;
+      }
+      throw new TransactionError(
+        6002 /* GAS_ESTIMATION_FAILED */,
+        `Failed to estimate gas on ${this._chain}: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          chain: this._chain,
+          cause: error instanceof Error ? error : void 0,
+          context: { to: params.to, value: params.value?.toString() }
+        }
+      );
+    }
+  }
+  /**
+   * Send a transaction (for advanced use cases)
+   *
+   * @throws {TransactionError} If transaction fails
+   */
+  async sendTransaction(params) {
+    if (!params.to || !params.to.startsWith("0x")) {
+      throw new TransactionError(
+        6001 /* TRANSACTION_FAILED */,
+        `Invalid 'to' address: ${params.to}`,
+        { chain: this._chain, context: params }
+      );
+    }
+    try {
+      const account = await this.getAccount();
+      const sendPromise = account.sendTransaction({
+        to: params.to,
+        value: params.value,
+        data: params.data
+      });
+      const hash = await withTimeout(
+        sendPromise,
+        this._timeoutMs * 2,
+        // Double timeout for transaction submission
+        "Sending transaction"
+      );
+      if (!hash || !hash.startsWith("0x")) {
+        throw new TransactionError(
+          6001 /* TRANSACTION_FAILED */,
+          `Invalid transaction hash received: ${hash?.substring(0, 10)}...`,
+          { chain: this._chain }
+        );
+      }
+      return { hash };
+    } catch (error) {
+      if (error instanceof TransactionError) {
+        throw error;
+      }
+      const wrapped = wrapError(error, 6001 /* TRANSACTION_FAILED */, "Transaction failed", {
+        chain: this._chain,
+        to: params.to
+      });
+      throw new TransactionError(
+        wrapped.code,
+        wrapped.message,
+        {
+          chain: this._chain,
+          cause: wrapped.cause,
+          context: wrapped.context
+        }
+      );
+    }
+  }
+};
+async function createWDKSigner(wdk, chain, accountIndex = 0, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const signer = new WDKSigner(wdk, chain, accountIndex, timeoutMs);
+  await signer.initialize();
+  return signer;
+}
+var MockWDKSigner = class {
+  constructor(address, privateKey) {
+    this.address = address;
+    this._privateKey = privateKey;
+  }
+  async signTypedData(_message) {
+    return "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+  }
+  async signMessage(_message) {
+    return "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+  }
+};
+
+// src/t402wdk.ts
+import { supportsBridging, getBridgeableChains } from "@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();
+    }
+  }
+  /**
+   * 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
+   *
+   * @example
+   * ```typescript
+   * import WDK from '@tetherto/wdk';
+   * import WalletManagerEvm from '@tetherto/wdk-wallet-evm';
+   * import BridgeUsdt0Evm from '@tetherto/wdk-protocol-bridge-usdt0-evm';
+   *
+   * T402WDK.registerWDK(WDK, WalletManagerEvm, BridgeUsdt0Evm);
+   * ```
+   */
+  static registerWDK(WDK, WalletManagerEvm, BridgeUsdt0Evm) {
+    if (!WDK) {
+      throw new WDKInitializationError("WDK constructor is required");
+    }
+    if (typeof WDK !== "function") {
+      throw new WDKInitializationError("WDK must be a constructor function");
+    }
+    _T402WDK._WDK = WDK;
+    _T402WDK._WalletManagerEvm = WalletManagerEvm ?? null;
+    _T402WDK._BridgeUsdt0Evm = BridgeUsdt0Evm ?? null;
+  }
+  /**
+   * Check if WDK is registered
+   */
+  static isWDKRegistered() {
+    return _T402WDK._WDK !== null;
+  }
+  /**
+   * Check if wallet manager is registered
+   */
+  static isWalletManagerRegistered() {
+    return _T402WDK._WalletManagerEvm !== null;
+  }
+  /**
+   * Check if bridge protocol is registered
+   */
+  static isBridgeRegistered() {
+    return _T402WDK._BridgeUsdt0Evm !== null;
+  }
+  /**
+   * Generate a new random seed phrase
+   *
+   * @throws {WDKInitializationError} If WDK is not registered
+   * @returns A new BIP-39 mnemonic seed phrase
+   */
+  static generateSeedPhrase() {
+    if (!_T402WDK._WDK) {
+      throw new WDKInitializationError(
+        "WDK not registered. Call T402WDK.registerWDK() first, or use a mock seed phrase for testing."
+      );
+    }
+    try {
+      return _T402WDK._WDK.getRandomSeedPhrase();
+    } catch (error) {
+      throw new WDKInitializationError(
+        `Failed to generate seed phrase: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  /**
+   * Add default chain configurations for common chains
+   */
+  _addDefaultChainsIfNeeded() {
+    if (this._normalizedChains.size === 0) {
+      const defaultEndpoint = DEFAULT_RPC_ENDPOINTS.arbitrum;
+      if (defaultEndpoint) {
+        this._normalizedChains.set(
+          "arbitrum",
+          normalizeChainConfig("arbitrum", defaultEndpoint)
+        );
+      }
+    }
+  }
+  /**
+   * Initialize the underlying WDK instance
+   */
+  _initializeWDK() {
+    if (!_T402WDK._WDK) {
+      this._initializationError = new WDKInitializationError("WDK not registered");
+      return;
+    }
+    if (!_T402WDK._WalletManagerEvm) {
+      this._initializationError = new WDKInitializationError(
+        "WalletManagerEvm not registered. Call T402WDK.registerWDK(WDK, WalletManagerEvm) to enable wallet functionality."
+      );
+      return;
+    }
+    try {
+      let wdk = new _T402WDK._WDK(this._seedPhrase);
+      for (const [chain, config] of this._normalizedChains) {
+        try {
+          wdk = wdk.registerWallet(chain, _T402WDK._WalletManagerEvm, {
+            provider: config.provider,
+            chainId: config.chainId
+          });
+        } catch (error) {
+          throw new ChainError(
+            2002 /* CHAIN_NOT_SUPPORTED */,
+            `Failed to register wallet for chain "${chain}": ${error instanceof Error ? error.message : String(error)}`,
+            { chain, cause: error instanceof Error ? error : void 0 }
+          );
+        }
+      }
+      if (_T402WDK._BridgeUsdt0Evm) {
+        try {
+          wdk = wdk.registerProtocol("bridge-usdt0", _T402WDK._BridgeUsdt0Evm);
+        } catch (error) {
+          console.warn(
+            `Failed to register USDT0 bridge protocol: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      this._wdk = wdk;
+      this._initializationError = null;
+    } catch (error) {
+      this._initializationError = error instanceof Error ? error : new Error(String(error));
+      this._wdk = null;
+    }
+  }
+  /**
+   * Get the underlying WDK instance
+   *
+   * @throws {WDKInitializationError} If WDK is not initialized
+   */
+  get wdk() {
+    if (this._initializationError) {
+      throw this._initializationError instanceof WDKError ? this._initializationError : new WDKInitializationError(
+        `WDK initialization failed: ${this._initializationError.message}`,
+        { cause: this._initializationError }
+      );
+    }
+    if (!this._wdk) {
+      throw new WDKInitializationError(
+        "WDK not initialized. Call T402WDK.registerWDK() before creating instances."
+      );
+    }
+    return this._wdk;
+  }
+  /**
+   * Check if WDK is properly initialized
+   */
+  get isInitialized() {
+    return this._wdk !== null && this._initializationError === null;
+  }
+  /**
+   * Get initialization error if any
+   */
+  get initializationError() {
+    return this._initializationError;
+  }
+  /**
+   * Get all configured chains
+   */
+  getConfiguredChains() {
+    return Array.from(this._normalizedChains.keys());
+  }
+  /**
+   * Get chain configuration
+   */
+  getChainConfig(chain) {
+    return this._normalizedChains.get(chain);
+  }
+  /**
+   * Check if a chain is configured
+   */
+  isChainConfigured(chain) {
+    return this._normalizedChains.has(chain);
+  }
+  /**
+   * Get a T402-compatible signer for a chain
+   *
+   * @param chain - Chain name (e.g., "arbitrum", "ethereum")
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @throws {ChainError} If chain is not configured
+   * @throws {SignerError} If signer creation fails
+   * @returns An initialized WDKSigner
+   */
+  async getSigner(chain, accountIndex = 0) {
+    if (!chain || typeof chain !== "string") {
+      throw new ChainError(
+        2001 /* CHAIN_NOT_CONFIGURED */,
+        "Chain name is required and must be a string",
+        { chain }
+      );
+    }
+    const cacheKey = `${chain}:${accountIndex}`;
+    const cached = this._signerCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    if (!this._normalizedChains.has(chain)) {
+      const availableChains = this.getConfiguredChains();
+      throw new ChainError(
+        2001 /* CHAIN_NOT_CONFIGURED */,
+        `Chain "${chain}" not configured. Available chains: ${availableChains.length > 0 ? availableChains.join(", ") : "(none)"}`,
+        { chain, context: { availableChains } }
+      );
+    }
+    try {
+      const signer = await createWDKSigner(this.wdk, chain, accountIndex);
+      this._signerCache.set(cacheKey, signer);
+      return signer;
+    } catch (error) {
+      if (isWDKError(error)) {
+        throw error;
+      }
+      throw wrapError(
+        error,
+        3001 /* SIGNER_NOT_INITIALIZED */,
+        `Failed to create signer for chain "${chain}"`,
+        { chain, accountIndex }
+      );
+    }
+  }
+  /**
+   * Clear the signer cache
+   * Useful for forcing re-initialization of signers
+   */
+  clearSignerCache() {
+    this._signerCache.clear();
+  }
+  /**
+   * Get wallet address for a chain
+   *
+   * @param chain - Chain name
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @throws {ChainError} If chain is not configured
+   * @throws {SignerError} If address fetch fails
+   */
+  async getAddress(chain, accountIndex = 0) {
+    const signer = await this.getSigner(chain, accountIndex);
+    return signer.address;
+  }
+  /**
+   * Get USDT0 balance for a chain
+   *
+   * Uses cache if enabled to reduce RPC calls.
+   *
+   * @throws {BalanceError} If balance fetch fails
+   */
+  async getUsdt0Balance(chain, accountIndex = 0) {
+    const usdt0Address = USDT0_ADDRESSES[chain];
+    if (!usdt0Address) {
+      return 0n;
+    }
+    try {
+      const signer = await this.getSigner(chain, accountIndex);
+      const address = signer.address;
+      return await this._balanceCache.getOrFetchTokenBalance(
+        chain,
+        usdt0Address,
+        address,
+        async () => signer.getTokenBalance(usdt0Address)
+      );
+    } catch (error) {
+      if (isWDKError(error) && error.code === 5002 /* TOKEN_BALANCE_FETCH_FAILED */) {
+        return 0n;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get USDC balance for a chain
+   *
+   * Uses cache if enabled to reduce RPC calls.
+   *
+   * @throws {BalanceError} If balance fetch fails
+   */
+  async getUsdcBalance(chain, accountIndex = 0) {
+    const usdcAddress = USDC_ADDRESSES[chain];
+    if (!usdcAddress) {
+      return 0n;
+    }
+    try {
+      const signer = await this.getSigner(chain, accountIndex);
+      const address = signer.address;
+      return await this._balanceCache.getOrFetchTokenBalance(
+        chain,
+        usdcAddress,
+        address,
+        async () => signer.getTokenBalance(usdcAddress)
+      );
+    } catch (error) {
+      if (isWDKError(error) && error.code === 5002 /* TOKEN_BALANCE_FETCH_FAILED */) {
+        return 0n;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get all token balances for a chain
+   *
+   * Uses cache if enabled to reduce RPC calls.
+   *
+   * @throws {ChainError} If chain is not configured
+   * @throws {BalanceError} If balance fetch fails
+   */
+  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 }
+      );
+    }
+    try {
+      const signer = await this.getSigner(chain, accountIndex);
+      const address = signer.address;
+      const tokens = CHAIN_TOKENS[chain] || [];
+      const tokenBalanceResults = await Promise.allSettled(
+        tokens.map(async (token) => {
+          const balance = await this._balanceCache.getOrFetchTokenBalance(
+            chain,
+            token.address,
+            address,
+            async () => signer.getTokenBalance(token.address)
+          );
+          return {
+            token: token.address,
+            symbol: token.symbol,
+            balance,
+            formatted: formatTokenAmount(balance, token.decimals),
+            decimals: token.decimals
+          };
+        })
+      );
+      const tokenBalances = tokenBalanceResults.map((result, index) => {
+        if (result.status === "fulfilled") {
+          return result.value;
+        }
+        const token = tokens[index];
+        return {
+          token: token.address,
+          symbol: token.symbol,
+          balance: 0n,
+          formatted: "0",
+          decimals: token.decimals
+        };
+      });
+      let nativeBalance;
+      try {
+        nativeBalance = await this._balanceCache.getOrFetchNativeBalance(
+          chain,
+          address,
+          async () => signer.getBalance()
+        );
+      } catch {
+        nativeBalance = 0n;
+      }
+      return {
+        chain,
+        network: config.network,
+        native: nativeBalance,
+        tokens: tokenBalances
+      };
+    } catch (error) {
+      if (isWDKError(error)) {
+        throw error;
+      }
+      throw new BalanceError(
+        5001 /* BALANCE_FETCH_FAILED */,
+        `Failed to get balances for chain "${chain}": ${error instanceof Error ? error.message : String(error)}`,
+        { chain, cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  /**
+   * Get aggregated balances across all configured chains
+   *
+   * @param accountIndex - HD wallet account index (default: 0)
+   * @param options - Options for balance aggregation
+   */
+  async getAggregatedBalances(accountIndex = 0, options = {}) {
+    const { continueOnError = true } = options;
+    const chains = this.getConfiguredChains();
+    const results = await Promise.allSettled(
+      chains.map((chain) => this.getChainBalances(chain, accountIndex))
+    );
+    const chainBalances = [];
+    const errors = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "fulfilled") {
+        chainBalances.push(result.value);
+      } else {
+        errors.push(result.reason);
+        if (!continueOnError) {
+          throw result.reason;
+        }
+        const config = this._normalizedChains.get(chains[i]);
+        if (config) {
+          chainBalances.push({
+            chain: chains[i],
+            network: config.network,
+            native: 0n,
+            tokens: []
+          });
+        }
+      }
+    }
+    let totalUsdt0 = 0n;
+    let totalUsdc = 0n;
+    for (const chainBalance of chainBalances) {
+      for (const token of chainBalance.tokens) {
+        if (token.symbol === "USDT0") {
+          totalUsdt0 += token.balance;
+        } else if (token.symbol === "USDC") {
+          totalUsdc += token.balance;
+        }
+      }
+    }
+    return {
+      totalUsdt0,
+      totalUsdc,
+      chains: chainBalances
+    };
+  }
+  /**
+   * Find the best chain for a payment
+   *
+   * Looks for the chain with sufficient balance, prioritizing USDT0.
+   *
+   * @param amount - Required amount in smallest units
+   * @param preferredToken - Preferred token ("USDT0" | "USDC")
+   * @throws {BalanceError} If balance aggregation fails
+   */
+  async findBestChainForPayment(amount, preferredToken = "USDT0") {
+    if (amount <= 0n) {
+      return null;
+    }
+    try {
+      const balances = await this.getAggregatedBalances(0, { continueOnError: true });
+      const tokenPriority = preferredToken === "USDT0" ? ["USDT0", "USDC"] : ["USDC", "USDT0"];
+      for (const tokenSymbol of tokenPriority) {
+        for (const chainBalance of balances.chains) {
+          const tokenBalance = chainBalance.tokens.find((t) => t.symbol === tokenSymbol);
+          if (tokenBalance && tokenBalance.balance >= amount) {
+            return {
+              chain: chainBalance.chain,
+              token: tokenSymbol,
+              balance: tokenBalance.balance
+            };
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      if (isWDKError(error)) {
+        throw error;
+      }
+      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() } }
+      );
+    }
+  }
+  /**
+   * Bridge USDT0 between chains
+   *
+   * Uses LayerZero OFT for cross-chain transfers.
+   *
+   * @param params - Bridge parameters
+   * @throws {BridgeError} If bridge is not available or fails
+   * @returns Bridge result with transaction hash
+   */
+  async bridgeUsdt0(params) {
+    if (!_T402WDK._BridgeUsdt0Evm) {
+      throw new BridgeError(
+        7001 /* BRIDGE_NOT_AVAILABLE */,
+        "USDT0 bridge not available. Register BridgeUsdt0Evm with T402WDK.registerWDK().",
+        { fromChain: params.fromChain, toChain: params.toChain }
+      );
+    }
+    if (!params.fromChain || !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 }
+      );
+    }
+    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() } }
+      );
+    }
+    if (!this.canBridge(params.fromChain, params.toChain)) {
+      throw new BridgeError(
+        7002 /* BRIDGE_NOT_SUPPORTED */,
+        `Bridging from "${params.fromChain}" to "${params.toChain}" is not supported`,
+        { fromChain: params.fromChain, toChain: params.toChain }
+      );
+    }
+    try {
+      const recipient = params.recipient ?? await this.getAddress(params.toChain);
+      const result = await this.wdk.executeProtocol("bridge-usdt0", {
+        fromChain: params.fromChain,
+        toChain: params.toChain,
+        amount: params.amount,
+        recipient
+      });
+      if (!result || !result.txHash) {
+        throw new BridgeError(
+          7003 /* BRIDGE_FAILED */,
+          "Bridge transaction did not return a transaction hash",
+          { fromChain: params.fromChain, toChain: params.toChain }
+        );
+      }
+      return {
+        txHash: result.txHash,
+        estimatedTime: 300
+        // ~5 minutes typical for LayerZero
+      };
+    } catch (error) {
+      if (error instanceof BridgeError) {
+        throw error;
+      }
+      throw new BridgeError(
+        7003 /* BRIDGE_FAILED */,
+        `Bridge operation failed: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          fromChain: params.fromChain,
+          toChain: params.toChain,
+          cause: error instanceof Error ? error : void 0,
+          context: { amount: params.amount.toString() }
+        }
+      );
+    }
+  }
+  /**
+   * Get chains that support USDT0
+   */
+  getUsdt0Chains() {
+    return this.getConfiguredChains().filter((chain) => USDT0_ADDRESSES[chain]);
+  }
+  /**
+   * Get chains that support USDT0 bridging
+   *
+   * Returns configured chains that have LayerZero OFT bridge support.
+   */
+  getBridgeableChains() {
+    return this.getConfiguredChains().filter((chain) => supportsBridging(chain));
+  }
+  /**
+   * Check if bridging is supported between two chains
+   */
+  canBridge(fromChain, toChain) {
+    return fromChain !== toChain && supportsBridging(fromChain) && supportsBridging(toChain) && this._normalizedChains.has(fromChain);
+  }
+  /**
+   * Get all possible bridge destinations from a chain
+   */
+  getBridgeDestinations(fromChain) {
+    if (!supportsBridging(fromChain)) {
+      return [];
+    }
+    return getBridgeableChains().filter((chain) => chain !== fromChain);
+  }
+  // ========== Cache Management ==========
+  /**
+   * Check if balance caching is enabled
+   */
+  get isCacheEnabled() {
+    return this._balanceCache.enabled;
+  }
+  /**
+   * Get cache configuration
+   */
+  getCacheConfig() {
+    return this._balanceCache.config;
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return this._balanceCache.getStats();
+  }
+  /**
+   * Invalidate all cached balances
+   *
+   * Call this after sending transactions to ensure fresh balance data.
+   */
+  invalidateBalanceCache() {
+    this._balanceCache.clear();
+  }
+  /**
+   * Invalidate cached balances for a specific chain
+   *
+   * @param chain - Chain name to invalidate
+   * @returns Number of cache entries invalidated
+   */
+  invalidateChainCache(chain) {
+    return this._balanceCache.invalidateChain(chain);
+  }
+  /**
+   * Invalidate cached balances for a specific address
+   *
+   * @param address - Address to invalidate (case-insensitive)
+   * @returns Number of cache entries invalidated
+   */
+  invalidateAddressCache(address) {
+    return this._balanceCache.invalidateAddress(address);
+  }
+  /**
+   * Dispose of cache resources
+   *
+   * Call this when the T402WDK instance is no longer needed.
+   */
+  dispose() {
+    this._balanceCache.dispose();
+    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";
+  }
+  const divisor = BigInt(10 ** decimals);
+  const whole = amount / divisor;
+  const fraction = amount % divisor;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionStr = fraction.toString().padStart(decimals, "0");
+  const trimmed = fractionStr.replace(/0+$/, "");
+  return `${whole}.${trimmed}`;
+}
+
+// src/bridge.ts
+import {
+  Usdt0Bridge,
+  supportsBridging as supportsBridging2,
+  getBridgeableChains as getBridgeableChains2
+} from "@t402/evm";
+var WdkBridge = class {
+  constructor() {
+    this.bridges = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create bridge signer adapter from WDK signer
+   */
+  createBridgeSigner(signer) {
+    return {
+      address: signer.address,
+      readContract: async (args) => {
+        throw new Error(
+          "readContract not available on WDKSigner. Use T402WDK.bridgeUsdt0() instead."
+        );
+      },
+      writeContract: async (args) => {
+        throw new Error(
+          "writeContract not available on WDKSigner. Use T402WDK.bridgeUsdt0() instead."
+        );
+      },
+      waitForTransactionReceipt: async (args) => {
+        throw new Error(
+          "waitForTransactionReceipt not available on WDKSigner. Use T402WDK.bridgeUsdt0() instead."
+        );
+      }
+    };
+  }
+  /**
+   * Get or create a bridge instance for a chain
+   */
+  getBridge(chain, signer) {
+    const cached = this.bridges.get(chain);
+    if (cached) {
+      return cached;
+    }
+    const bridgeSigner = this.createBridgeSigner(signer);
+    const bridge = new Usdt0Bridge(bridgeSigner, chain);
+    this.bridges.set(chain, bridge);
+    return bridge;
+  }
+  /**
+   * Check if a chain supports USDT0 bridging
+   */
+  static supportsBridging(chain) {
+    return supportsBridging2(chain);
+  }
+  /**
+   * Get all chains that support USDT0 bridging
+   */
+  static getBridgeableChains() {
+    return getBridgeableChains2();
+  }
+  /**
+   * Get supported destinations from a source chain
+   */
+  static getSupportedDestinations(fromChain) {
+    return getBridgeableChains2().filter((chain) => chain !== fromChain);
+  }
+};
+function createDirectBridge(signer, chain) {
+  return new Usdt0Bridge(signer, chain);
+}
+
+// src/index.ts
+import {
+  supportsBridging as supportsBridging3,
+  getBridgeableChains as getBridgeableChains3,
+  LAYERZERO_ENDPOINT_IDS,
+  USDT0_OFT_ADDRESSES,
+  Usdt0Bridge as Usdt0Bridge2
+} from "@t402/evm";
+export {
+  BalanceCache,
+  BalanceError,
+  BridgeError,
+  CHAIN_TOKENS,
+  ChainError,
+  DEFAULT_BALANCE_CACHE_CONFIG,
+  DEFAULT_CACHE_CONFIG,
+  DEFAULT_CHAINS,
+  DEFAULT_RETRY_CONFIG,
+  DEFAULT_RPC_ENDPOINTS,
+  LAYERZERO_ENDPOINT_IDS,
+  MockWDKSigner,
+  RPCError,
+  SignerError,
+  SigningError,
+  T402WDK,
+  TTLCache,
+  TransactionError,
+  USDC_ADDRESSES,
+  USDT0_ADDRESSES,
+  USDT0_OFT_ADDRESSES,
+  USDT_LEGACY_ADDRESSES,
+  Usdt0Bridge2 as Usdt0Bridge,
+  WDKError,
+  WDKErrorCode,
+  WDKInitializationError,
+  WDKSigner,
+  WdkBridge,
+  createDirectBridge,
+  createWDKSigner,
+  getBridgeableChains3 as getBridgeableChains,
+  getChainFromNetwork,
+  getChainId,
+  getNetworkFromChain,
+  getPreferredToken,
+  getUsdt0Chains,
+  hasErrorCode,
+  isWDKError,
+  normalizeChainConfig,
+  supportsBridging3 as supportsBridging,
+  withRetry,
+  withTimeout,
+  wrapError
+};
+//# sourceMappingURL=index.mjs.map