@talken/talkenkit 2.4.22 → 2.4.24

package/dist/wallets/walletConnectors/chunk-GGPJJ6KS.js

@@ -0,0 +1,1407 @@
+"use client";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-UAV4SI4Y.js";
+import {
+  getCredentialManager
+} from "./chunk-MTC2HJPF.js";
+
+// src/wallets/walletConnectors/abcWallet/abcProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+import { parseGwei } from "viem";
+
+// src/config/networks.ts
+var NETWORK_CONFIGS = {
+  // Ethereum Mainnet
+  1: {
+    chainId: 1,
+    network: "ethereum",
+    name: "Ethereum",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://etherscan.io",
+    website: "https://ethereum.org",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Ethereum Sepolia Testnet
+  11155111: {
+    chainId: 11155111,
+    network: "ethereum_sepolia",
+    name: "Ethereum Sepolia",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://sepolia.etherscan.io",
+    website: "https://ethereum.org",
+    nativeCurrency: {
+      name: "Sepolia Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Ethereum Holesky Testnet
+  17e3: {
+    chainId: 17e3,
+    network: "ethereum_holesky",
+    name: "Ethereum Holesky",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://holesky.etherscan.io",
+    website: "https://ethereum.org",
+    nativeCurrency: {
+      name: "Holesky Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Kaia Mainnet (formerly Klaytn)
+  8217: {
+    chainId: 8217,
+    network: "kaia",
+    name: "Kaia Mainnet",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://kaiascan.io",
+    website: "https://kaia.io",
+    nativeCurrency: {
+      name: "Kaia",
+      symbol: "KAIA",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Kaia Kairos Testnet
+  1001: {
+    chainId: 1001,
+    network: "kaia_kairos",
+    name: "Kaia Kairos Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://kairos.kaiascan.io",
+    website: "https://kaia.io",
+    nativeCurrency: {
+      name: "Kaia",
+      symbol: "KAIA",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Polygon Mainnet
+  137: {
+    chainId: 137,
+    network: "polygon",
+    name: "Polygon",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://polygonscan.com",
+    website: "https://polygon.technology",
+    nativeCurrency: {
+      name: "MATIC",
+      symbol: "MATIC",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Polygon Amoy Testnet
+  80001: {
+    chainId: 80001,
+    network: "polygon_amoy",
+    name: "Polygon Amoy Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://amoy.polygonscan.com",
+    website: "https://polygon.technology",
+    nativeCurrency: {
+      name: "MATIC",
+      symbol: "MATIC",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Binance Smart Chain Mainnet
+  56: {
+    chainId: 56,
+    network: "binance",
+    name: "Binance Smart Chain Mainnet",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://bscscan.com",
+    website: "https://www.bnbchain.org/en/bnb-smart-chain",
+    nativeCurrency: {
+      name: "BNB",
+      symbol: "BNB",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Binance Smart Chain Testnet
+  97: {
+    chainId: 97,
+    network: "binance_testnet",
+    name: "Binance Smart Chain Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://testnet.bscscan.com",
+    website: "https://www.bnbchain.org/en/bnb-smart-chain",
+    nativeCurrency: {
+      name: "BNB",
+      symbol: "BNB",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Arbitrum One
+  42161: {
+    chainId: 42161,
+    network: "arbitrum",
+    name: "Arbitrum One",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://arbiscan.io",
+    website: "https://arbitrum.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Arbitrum Sepolia
+  421614: {
+    chainId: 421614,
+    network: "arbitrum_sepolia",
+    name: "Arbitrum Sepolia",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://sepolia.arbiscan.io",
+    website: "https://arbitrum.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Optimism Mainnet
+  10: {
+    chainId: 10,
+    network: "optimism",
+    name: "Optimism",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://optimistic.etherscan.io",
+    website: "https://optimism.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Optimism Sepolia
+  420: {
+    chainId: 420,
+    network: "optimism_sepolia",
+    name: "Optimism Sepolia",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://sepolia-optimism.etherscan.io",
+    website: "https://optimism.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Avalanche C-Chain
+  43114: {
+    chainId: 43114,
+    network: "avalanche",
+    name: "Avalanche C-Chain",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://avascan.info/blockchain/c/home",
+    website: "https://avax.network",
+    nativeCurrency: {
+      name: "Avalanche",
+      symbol: "AVAX",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Avalanche Fuji Testnet
+  43113: {
+    chainId: 43113,
+    network: "avalanche_fuji",
+    name: "Avalanche Fuji Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://testnet.avascan.info",
+    website: "https://avax.network",
+    nativeCurrency: {
+      name: "Avalanche",
+      symbol: "AVAX",
+      decimals: 18
+    },
+    apiSupport: { tokens: false, nft: false, transactions: false },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Mantle Mainnet
+  5e3: {
+    chainId: 5e3,
+    network: "mantle",
+    name: "Mantle Mainnet",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://explorer.mantle.xyz",
+    website: "https://www.mantle.xyz",
+    nativeCurrency: {
+      name: "Mantle",
+      symbol: "MNT",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Mantle Testnet
+  5001: {
+    chainId: 5001,
+    network: "mantle_testnet",
+    name: "Mantle Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://sepolia.mantlescan.xyz",
+    website: "https://www.mantle.xyz",
+    nativeCurrency: {
+      name: "Mantle",
+      symbol: "MNT",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Moonbeam
+  1284: {
+    chainId: 1284,
+    network: "moonbeam",
+    name: "Moonbeam",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://moonbeam.moonscan.io",
+    website: "https://moonbeam.network",
+    nativeCurrency: {
+      name: "Glimmer",
+      symbol: "GLMR",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Moonriver
+  1285: {
+    chainId: 1285,
+    network: "moonriver",
+    name: "Moonriver",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://moonriver.moonscan.io",
+    website: "https://moonbeam.network/networks/moonriver",
+    nativeCurrency: {
+      name: "Moonriver",
+      symbol: "MOVR",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Scroll Mainnet
+  534352: {
+    chainId: 534352,
+    network: "scroll",
+    name: "Scroll",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://scrollscan.co",
+    website: "https://scroll.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Scroll Testnet
+  534351: {
+    chainId: 534351,
+    network: "scroll_testnet",
+    name: "Scroll Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://sepolia.scrollscan.com",
+    website: "https://scroll.io",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Silicon Mainnet
+  2355: {
+    chainId: 2355,
+    network: "silicon",
+    name: "Silicon",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://scope.silicon.network",
+    website: "https://silicon.network",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Silicon Sepolia
+  1722641160: {
+    chainId: 1722641160,
+    network: "silicon_sepolia",
+    name: "Silicon Sepolia",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://scope-sepolia.silicon.network",
+    website: "https://silicon.network",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Six Protocol
+  98: {
+    chainId: 98,
+    network: "six_evm",
+    name: "Six Protocol",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://v2.sixscan.io",
+    website: "https://www.six.network",
+    nativeCurrency: {
+      name: "SIX",
+      symbol: "SIX",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: false, transactions: true },
+    signSupport: { legacy: true, eip1559: false }
+  },
+  // Six Protocol Testnet
+  150: {
+    chainId: 150,
+    network: "six_evm_testnet",
+    name: "Six Protocol Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://v2.fivenet.sixscan.io",
+    website: "https://www.six.network",
+    nativeCurrency: {
+      name: "SIX",
+      symbol: "SIX",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: false, transactions: true },
+    signSupport: { legacy: true, eip1559: false }
+  },
+  // Wemix Mainnet
+  1111: {
+    chainId: 1111,
+    network: "wemix",
+    name: "Wemix3.0 Mainnet",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://explorer.wemix.com",
+    website: "https://wemix.com",
+    nativeCurrency: {
+      name: "WEMIX",
+      symbol: "WEMIX",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Wemix Testnet
+  1112: {
+    chainId: 1112,
+    network: "wemix_testnet",
+    name: "Wemix3.0 Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://explorer.test.wemix.com",
+    website: "https://wemix.com",
+    nativeCurrency: {
+      name: "WEMIX",
+      symbol: "WEMIX",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Taiko Mainnet
+  167e3: {
+    chainId: 167e3,
+    network: "taiko",
+    name: "Taiko Mainnet",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://taikoscan.io",
+    website: "https://taiko.xyz",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Taiko Hekla Testnet
+  167009: {
+    chainId: 167009,
+    network: "taiko_hekla",
+    name: "Taiko Hekla Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://hekla.taikoscan.io",
+    website: "https://taiko.xyz",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Base Mainnet
+  8453: {
+    chainId: 8453,
+    network: "base",
+    name: "Base",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://basescan.org",
+    website: "https://base.org",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Base Sepolia Testnet
+  84532: {
+    chainId: 84532,
+    network: "base_sepolia",
+    name: "Base Sepolia",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://sepolia.basescan.org",
+    website: "https://base.org",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // ChainBounty Mainnet
+  51828: {
+    chainId: 51828,
+    network: "chainbounty",
+    name: "ChainBounty Mainnet",
+    type: "EVM" /* EVM */,
+    isTestnet: false,
+    explorer: "https://scan.chainbounty.io",
+    website: "https://chainbounty.io",
+    nativeCurrency: {
+      name: "ChainBounty",
+      symbol: "CBY",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // ChainBounty Testnet
+  56580: {
+    chainId: 56580,
+    network: "chainbounty_testnet",
+    name: "ChainBounty Testnet",
+    type: "EVM" /* EVM */,
+    isTestnet: true,
+    explorer: "https://test.scan.chainbounty.io",
+    website: "https://chainbounty.io",
+    nativeCurrency: {
+      name: "ChainBounty",
+      symbol: "CBY",
+      decimals: 18
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Aptos Mainnet (Non-EVM)
+  aptos: {
+    chainId: null,
+    network: "aptos",
+    name: "Aptos",
+    type: "Non-EVM" /* NON_EVM */,
+    isTestnet: false,
+    explorer: "https://explorer.aptoslabs.com/?network=mainnet",
+    website: "https://aptos.dev",
+    nativeCurrency: {
+      name: "Aptos",
+      symbol: "APT",
+      decimals: 8
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: false }
+  },
+  // Aptos Testnet (Non-EVM)
+  aptos_testnet: {
+    chainId: null,
+    network: "aptos_testnet",
+    name: "Aptos Testnet",
+    type: "Non-EVM" /* NON_EVM */,
+    isTestnet: true,
+    explorer: "https://explorer.aptoslabs.com/?network=testnet",
+    website: "https://aptos.dev",
+    nativeCurrency: {
+      name: "Aptos",
+      symbol: "APT",
+      decimals: 8
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: false }
+  },
+  // Bitcoin Mainnet
+  bitcoin: {
+    chainId: null,
+    network: "bitcoin",
+    name: "Bitcoin Mainnet",
+    type: "Bitcoin" /* BITCOIN */,
+    isTestnet: false,
+    explorer: "https://blockstream.info",
+    website: "https://bitcoin.org",
+    nativeCurrency: {
+      name: "Bitcoin",
+      symbol: "BTC",
+      decimals: 8
+    },
+    apiSupport: { tokens: true, nft: false, transactions: true },
+    signSupport: { legacy: true, eip1559: false }
+  },
+  // Bitcoin Testnet
+  bitcoin_testnet: {
+    chainId: null,
+    network: "bitcoin_testnet",
+    name: "Bitcoin Testnet",
+    type: "Bitcoin" /* BITCOIN */,
+    isTestnet: true,
+    explorer: "https://blockstream.info/testnet",
+    website: "https://bitcoin.org",
+    nativeCurrency: {
+      name: "Bitcoin",
+      symbol: "BTC",
+      decimals: 8
+    },
+    apiSupport: { tokens: true, nft: false, transactions: true },
+    signSupport: { legacy: true, eip1559: false }
+  },
+  // Tron Mainnet
+  tron: {
+    chainId: null,
+    network: "tron",
+    name: "Tron Mainnet",
+    type: "TRX" /* TRON */,
+    isTestnet: false,
+    explorer: "https://tronscan.org",
+    website: "https://tron.network",
+    nativeCurrency: {
+      name: "Tronix",
+      symbol: "TRX",
+      decimals: 6
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // Tron Nile Testnet
+  tron_nile: {
+    chainId: null,
+    network: "tron_nile",
+    name: "Tron Nile Testnet",
+    type: "TRX" /* TRON */,
+    isTestnet: true,
+    explorer: "https://nile.tronscan.org",
+    website: "https://tron.network",
+    nativeCurrency: {
+      name: "Tronix",
+      symbol: "TRX",
+      decimals: 6
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  },
+  // ICP Mainnet
+  icp: {
+    chainId: null,
+    network: "icp",
+    name: "Internet Computer",
+    type: "ICP" /* ICP */,
+    isTestnet: false,
+    explorer: "https://dashboard.internetcomputer.org",
+    website: "https://internetcomputer.org",
+    nativeCurrency: {
+      name: "ICP",
+      symbol: "ICP",
+      decimals: 8
+    },
+    apiSupport: { tokens: true, nft: true, transactions: true },
+    signSupport: { legacy: true, eip1559: true }
+  }
+};
+var NETWORK_BY_PARAM = Object.values(
+  NETWORK_CONFIGS
+).reduce(
+  (acc, config) => {
+    acc[config.network] = config;
+    return acc;
+  },
+  {}
+);
+function getNetworkName(chainId, fallback = "ethereum") {
+  return NETWORK_CONFIGS[chainId]?.network ?? fallback;
+}
+var CHAIN_ID_TO_KEY = {
+  // Mainnet
+  1: "ethereum",
+  42161: "arbitrum",
+  8217: "kaia",
+  56: "bsc",
+  8453: "base",
+  137: "polygon",
+  // Testnet
+  11155111: "sepolia",
+  421614: "arbitrumSepolia",
+  1001: "kaiaKairos",
+  97: "bscTestnet",
+  84532: "baseSepolia",
+  80002: "polygonAmoy",
+  998: "hyperevmTestnet"
+};
+function getChainKey(chainId) {
+  const key = CHAIN_ID_TO_KEY[chainId];
+  if (!key) {
+    throw new Error(`Unsupported chainId for tx endpoint: ${chainId}`);
+  }
+  return key;
+}
+
+// src/wallets/walletConnectors/abcWallet/abcProvider.ts
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+      return true;
+    }
+    return false;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+};
+var ProviderRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "ProviderRpcError";
+  }
+};
+var ErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  CHAIN_DISCONNECTED: 4901,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var AbcEvmProvider = class extends EventEmitter {
+  constructor(talkenApi) {
+    super();
+    this.wallet = null;
+    this.chainId = 1;
+    // Default to Ethereum mainnet
+    this.connected = false;
+    this.talkenApi = talkenApi;
+  }
+  getRecoveryEmail() {
+    const walletEmail = this.wallet?.email?.trim();
+    if (walletEmail) {
+      return walletEmail;
+    }
+    return getCredentialManager().getEmail() || void 0;
+  }
+  /**
+   * Set wallet information
+   */
+  setWallet(wallet) {
+    const previousAddress = this.wallet?.address;
+    const previousChainId = this.chainId;
+    this.wallet = wallet;
+    this.chainId = wallet.chainId;
+    this.connected = true;
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+    }
+    if (previousChainId !== wallet.chainId) {
+      this.emit("chainChanged", numberToHex(wallet.chainId));
+    }
+    this.emit("connect", { chainId: numberToHex(wallet.chainId) });
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.emit("disconnect", {
+      code: ErrorCode.DISCONNECTED,
+      message: "User disconnected"
+    });
+    this.emit("accountsChanged", []);
+  }
+  /**
+   * Set request interceptor for sign confirmation
+   * The interceptor is called before signing operations to show confirmation UI
+   */
+  setRequestInterceptor(interceptor) {
+    this.requestInterceptor = interceptor;
+  }
+  /**
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, transaction methods will use a single API call instead of multi-step WaaS
+   */
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  getTalkenApiClientOrThrow() {
+    const api = this.talkenApi || getTalkenApiClient();
+    if (!api) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "TalkenApiClient not initialized"
+      );
+    }
+    return api;
+  }
+  /**
+   * Call request interceptor if configured
+   * Called by specific signing/transaction methods that need user confirmation
+   * @returns Resolved transaction with user modifications if changed in confirmation modal
+   */
+  async callInterceptor(method, params) {
+    if (!this.requestInterceptor) {
+      return void 0;
+    }
+    const request = {
+      method,
+      params,
+      chainId: this.chainId,
+      address: this.wallet?.address || ""
+    };
+    return this.requestInterceptor(request);
+  }
+  /**
+   * EIP-1193 request method
+   */
+  async request(args) {
+    const { method, params } = args;
+    switch (method) {
+      case "eth_requestAccounts":
+        return this.eth_requestAccounts();
+      case "eth_accounts":
+        return this.eth_accounts();
+      case "eth_chainId":
+        return this.eth_chainId();
+      case "eth_sendTransaction":
+      case "wallet_sendTransaction":
+        return this.eth_sendTransaction(params);
+      case "eth_signTransaction":
+        return this.eth_signTransaction(params);
+      case "personal_sign":
+        return this.personal_sign(params);
+      case "eth_sign":
+        return this.eth_sign(params);
+      case "eth_signTypedData":
+      case "eth_signTypedData_v3":
+      case "eth_signTypedData_v4":
+        return this.eth_signTypedData(params);
+      case "wallet_getCapabilities":
+        return this.wallet_getCapabilities();
+      case "eth_signAuthorization":
+        return this.eth_signAuthorization(params);
+      case "wallet_switchEthereumChain":
+        return this.wallet_switchEthereumChain(params);
+      case "wallet_addEthereumChain":
+        return this.wallet_addEthereumChain(params);
+      case "eth_estimateGas":
+        return this.eth_estimateGas(params);
+      case "eth_getTransactionCount":
+        return this.eth_getTransactionCount(
+          Array.isArray(params) ? params : []
+        );
+      case "eth_blockNumber":
+      case "eth_call":
+      case "eth_gasPrice":
+      case "eth_getBalance":
+      case "eth_getBlockByHash":
+      case "eth_getBlockByNumber":
+      case "eth_getCode":
+      case "eth_getStorageAt":
+      case "eth_getTransactionByHash":
+      case "eth_getTransactionReceipt":
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method ${method} should be handled by RPC provider`
+        );
+      default:
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method ${method} not supported`
+        );
+    }
+  }
+  /**
+   * Request accounts (EIP-1193)
+   */
+  async eth_requestAccounts() {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    return [this.wallet.address];
+  }
+  /**
+   * Get accounts
+   */
+  async eth_accounts() {
+    if (!this.wallet) {
+      return [];
+    }
+    return [this.wallet.address];
+  }
+  /**
+   * Get chain ID
+   */
+  async eth_chainId() {
+    return numberToHex(this.chainId);
+  }
+  /**
+   * Send transaction
+   */
+  async eth_sendTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid transaction params"
+      );
+    }
+    const resolved = await this.callInterceptor("eth_sendTransaction", params);
+    const tx = params[0];
+    console.log("[AbcProvider] eth_sendTransaction incoming gas params:", {
+      gas: tx.gas ?? tx.gasLimit,
+      gasPrice: tx.gasPrice,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+    });
+    if (resolved) {
+      if (resolved.data) {
+        tx.data = resolved.data;
+      }
+      if (resolved.gasFee?.maxFeePerGas) {
+        try {
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
+          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
+            error
+          );
+        }
+      }
+      if (resolved.gasFee?.maxPriorityFeePerGas) {
+        try {
+          const priorityFeeWei = parseGwei(
+            resolved.gasFee.maxPriorityFeePerGas
+          );
+          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
+            error
+          );
+        }
+      }
+    }
+    console.log("[AbcProvider] eth_sendTransaction final gas params:", {
+      gas: tx.gas ?? tx.gasLimit,
+      gasPrice: tx.gasPrice,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+    });
+    const isContractDeployment = !tx.to || tx.to === "0x" || tx.to === "0x0" || tx.to === "0x0000000000000000000000000000000000000000";
+    if (isContractDeployment) {
+      tx.to = "0x";
+    } else if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        'Transaction must have "to" field'
+      );
+    }
+    const pinHash = getCredentialManager().getPinHash();
+    if (!pinHash) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "PIN hash not found. Please login again."
+      );
+    }
+    const hexValue = tx.value || "0x0";
+    const amountWei = BigInt(hexValue).toString();
+    const email = this.getRecoveryEmail();
+    const api = this.getTalkenApiClientOrThrow();
+    const result = await api.evm.sendTransaction({
+      chainKey: getChainKey(this.chainId),
+      to: tx.to,
+      amountWei,
+      pin: pinHash,
+      data: tx.data || "0x",
+      gasLimit: tx.gas || tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      ...email && { email }
+    });
+    return result.txHash;
+  }
+  /**
+   * Sign transaction (without sending)
+   */
+  async eth_signTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid transaction params"
+      );
+    }
+    const resolved = await this.callInterceptor("eth_signTransaction", params);
+    const tx = params[0];
+    if (resolved) {
+      if (resolved.data) {
+        tx.data = resolved.data;
+      }
+      if (resolved.gasFee?.maxFeePerGas) {
+        try {
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
+          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
+            error
+          );
+        }
+      }
+      if (resolved.gasFee?.maxPriorityFeePerGas) {
+        try {
+          const priorityFeeWei = parseGwei(
+            resolved.gasFee.maxPriorityFeePerGas
+          );
+          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
+            error
+          );
+        }
+      }
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await api.evm.signTransaction({
+      network: getNetworkName(this.chainId),
+      to: tx.to,
+      value: tx.value || "0x0",
+      data: tx.data || "0x",
+      gasLimit: tx.gas || tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      nonce: tx.nonce ? String(Number.parseInt(tx.nonce, 16)) : void 0,
+      ...pinHash && { pin: pinHash },
+      ...email && { email }
+    });
+    return result.signature;
+  }
+  /**
+   * Personal sign (EIP-191)
+   */
+  async personal_sign(params) {
+    if (!this.wallet) {
+      console.error("[AbcProvider] \u274C Wallet not connected");
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      console.error("[AbcProvider] \u274C Invalid params:", params);
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid personal_sign params"
+      );
+    }
+    await this.callInterceptor("personal_sign", params);
+    const [message, address] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      console.error("[AbcProvider] \u274C Address mismatch");
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const network = getNetworkName(this.chainId);
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await api.evm.signPersonal({
+      network,
+      message,
+      address,
+      pin: pinHash,
+      ...email && { email }
+    });
+    return result.signature;
+  }
+  /**
+   * Eth sign
+   */
+  async eth_sign(params) {
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid eth_sign params"
+      );
+    }
+    const [address, message] = params;
+    return this.personal_sign([message, address]);
+  }
+  /**
+   * Sign typed data (EIP-712)
+   */
+  async eth_signTypedData(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid signTypedData params"
+      );
+    }
+    await this.callInterceptor("eth_signTypedData_v4", params);
+    const [address, typedData] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const network = getNetworkName(this.chainId);
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await api.evm.signTypedData({
+      network,
+      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
+      pin: pinHash,
+      ...email && { email }
+    });
+    return result.signature;
+  }
+  /**
+   * Return normalized wallet capabilities for ABC embedded wallets.
+   * ABC supports EIP-7702 authorization signing via talken-api.
+   */
+  async wallet_getCapabilities() {
+    return {
+      supportsTypedDataV4: true,
+      supports7702Authorization: true,
+      supports5792Batch: false,
+      supportsPaymasterService: false,
+      supportsPermit2RelayHints: true,
+      walletType: "abc-embedded"
+    };
+  }
+  /**
+   * Sign EIP-7702 authorization via Talken API.
+   */
+  async eth_signAuthorization(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid signAuthorization params"
+      );
+    }
+    const [address, authorization] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    if (!authorization?.address || authorization.chainId == null || authorization.nonce == null) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Authorization payload is incomplete"
+      );
+    }
+    await this.callInterceptor("eth_signAuthorization", params);
+    const api = this.getTalkenApiClientOrThrow();
+    const network = getNetworkName(this.chainId);
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const chainIdValue = typeof authorization.chainId === "string" ? Number(BigInt(authorization.chainId)) : Number(authorization.chainId);
+    const nonceValue = typeof authorization.nonce === "string" ? BigInt(authorization.nonce).toString() : String(authorization.nonce);
+    const result = await api.evm.signAuthorization({
+      network,
+      authorization: {
+        chainId: chainIdValue,
+        address: authorization.address,
+        nonce: nonceValue
+      },
+      pin: pinHash,
+      ...email && { email }
+    });
+    return result.authorization;
+  }
+  /**
+   * Switch Ethereum chain
+   */
+  async wallet_switchEthereumChain(params) {
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid switchEthereumChain params"
+      );
+    }
+    const { chainId } = params[0];
+    const newChainId = hexToNumber(chainId);
+    if (this.chainId === newChainId) {
+      return null;
+    }
+    const _previousChainId = this.chainId;
+    this.chainId = newChainId;
+    if (this.wallet) {
+      this.wallet.chainId = newChainId;
+    }
+    this.emit("chainChanged", numberToHex(newChainId));
+    return null;
+  }
+  /**
+   * Add Ethereum chain
+   */
+  async wallet_addEthereumChain(params) {
+    return this.wallet_switchEthereumChain(params);
+  }
+  /**
+   * Get transaction count (nonce) using ABC WaaS API
+   */
+  async eth_getTransactionCount(params) {
+    const address = params[0]?.toLowerCase();
+    if (!address) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Missing address parameter"
+      );
+    }
+    const currentChainId = this.chainId;
+    try {
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.getNonce(
+        getNetworkName(currentChainId),
+        address
+      );
+      const nonce = response.result !== void 0 ? typeof response.result === "number" ? `0x${response.result.toString(16)}` : response.result : void 0;
+      if (!nonce) {
+        throw new Error("No result in nonce response");
+      }
+      return nonce;
+    } catch (error) {
+      console.error(
+        "[AbcEvmProvider] \u274C Failed to get transaction count from ABC WaaS:",
+        error
+      );
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        `Failed to get transaction count: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Estimate gas for transaction
+   * Uses ABC WaaS gas estimation API with fallback
+   */
+  async eth_estimateGas(params) {
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid estimateGas params"
+      );
+    }
+    const tx = params[0];
+    if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        'Transaction must have "to" field'
+      );
+    }
+    try {
+      const response = await this.getTalkenApiClientOrThrow().evm.estimateGas({
+        network: getNetworkName(this.chainId),
+        from: tx.from || this.wallet?.address || "",
+        to: tx.to,
+        value: tx.value,
+        data: tx.data
+      });
+      if (!response.result) {
+        throw new Error("No result in gas estimate response");
+      }
+      return response.result;
+    } catch (error) {
+      console.warn(
+        "[AbcEvmProvider] Gas estimation failed, using fallback:",
+        error
+      );
+      if (tx.data && tx.data !== "0x") {
+        return "0x493e0";
+      }
+      return "0x5208";
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get current chain ID
+   */
+  getChainId() {
+    return this.chainId;
+  }
+};
+function createAbcEvmProvider(talkenApi) {
+  return new AbcEvmProvider(talkenApi);
+}
+var createAbcProvider = createAbcEvmProvider;
+
+export {
+  AbcEvmProvider,
+  createAbcEvmProvider,
+  createAbcProvider
+};