@swapkit/wallets 4.7.0 → 4.8.1

package/src/types.ts

@@ -0,0 +1,137 @@
+import { WalletOption } from "@swapkit/helpers";
+import type { bitgetWallet } from "@swapkit/wallet-extensions/bitget";
+import type { cosmostationWallet } from "@swapkit/wallet-extensions/cosmostation";
+import type { ctrlWallet } from "@swapkit/wallet-extensions/ctrl";
+import type { evmWallet } from "@swapkit/wallet-extensions/evm-extensions";
+import type { keepkeyBexWallet } from "@swapkit/wallet-extensions/keepkey-bex";
+import type { keplrWallet } from "@swapkit/wallet-extensions/keplr";
+import type { okxWallet } from "@swapkit/wallet-extensions/okx";
+import type { onekeyWallet } from "@swapkit/wallet-extensions/onekey";
+import type { petraWallet } from "@swapkit/wallet-extensions/petra";
+import type { phantomWallet } from "@swapkit/wallet-extensions/phantom";
+import type { polkadotWallet } from "@swapkit/wallet-extensions/polkadotjs";
+import type { talismanWallet } from "@swapkit/wallet-extensions/talisman";
+import type { tronlinkWallet } from "@swapkit/wallet-extensions/tronlink";
+import type { trustwalletWallet } from "@swapkit/wallet-extensions/trustwallet";
+import type { vultisigWallet } from "@swapkit/wallet-extensions/vultisig";
+import type { keepkeyWallet } from "@swapkit/wallet-hardware/keepkey";
+import type { ledgerWallet } from "@swapkit/wallet-hardware/ledger";
+import type { trezorWallet } from "@swapkit/wallet-hardware/trezor";
+import type { coinbaseWallet } from "./coinbase";
+import type { keystoreWallet } from "./keystore";
+import type { walletSelectorWallet } from "./near-wallet-selector";
+import type { passkeysWallet } from "./passkeys";
+import type { radixWallet } from "./radix";
+import type { walletconnectWallet } from "./walletconnect";
+import type { xamanWallet } from "./xaman";
+
+export type SKWallets = {
+  [WalletOption.BITGET]: typeof bitgetWallet;
+  [WalletOption.BRAVE]: typeof evmWallet;
+  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet;
+  [WalletOption.COINBASE_WEB]: typeof evmWallet;
+  [WalletOption.COSMOSTATION]: typeof cosmostationWallet;
+  [WalletOption.CTRL]: typeof ctrlWallet;
+  [WalletOption.EIP6963]: typeof evmWallet;
+  [WalletOption.EXODUS]: typeof passkeysWallet;
+  [WalletOption.KEEPKEY]: typeof keepkeyWallet;
+  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet;
+  [WalletOption.KEPLR]: typeof keplrWallet;
+  [WalletOption.KEYSTORE]: typeof keystoreWallet;
+  [WalletOption.LEAP]: typeof keplrWallet;
+  [WalletOption.LEDGER]: typeof ledgerWallet;
+  [WalletOption.METAMASK]: typeof evmWallet;
+  [WalletOption.OKX]: typeof okxWallet;
+  [WalletOption.OKX_MOBILE]: typeof evmWallet;
+  [WalletOption.ONEKEY]: typeof onekeyWallet;
+  [WalletOption.PASSKEYS]: typeof passkeysWallet;
+  [WalletOption.PETRA]: typeof petraWallet;
+  [WalletOption.PHANTOM]: typeof phantomWallet;
+  [WalletOption.POLKADOT_JS]: typeof polkadotWallet;
+  [WalletOption.RADIX_WALLET]: typeof radixWallet;
+  [WalletOption.TALISMAN]: typeof talismanWallet;
+  [WalletOption.TREZOR]: typeof trezorWallet;
+  [WalletOption.TRONLINK]: typeof tronlinkWallet;
+  [WalletOption.TRUSTWALLET_WEB]: typeof trustwalletWallet;
+  [WalletOption.VULTISIG]: typeof vultisigWallet;
+  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
+  [WalletOption.WALLET_SELECTOR]: typeof walletSelectorWallet;
+  [WalletOption.XAMAN]: typeof xamanWallet;
+};
+
+export type SKConnectWallets = SKWallets[keyof SKWallets];
+
+export type HDWalletAccountParams = { accountIndex?: number };
+
+export type HDWalletDeriveAddressParams = HDWalletAccountParams & { index: number; change?: boolean };
+
+export type HDWalletDeriveAddressesParams = HDWalletAccountParams & {
+  count: number;
+  startIndex?: number;
+  change?: boolean;
+};
+
+export type HDWalletDerivedAddress = {
+  address: string;
+  index: number;
+  change: boolean;
+  path: string;
+  accountIndex: number;
+  pubkey: string;
+};
+
+export type HDWalletExtendedPublicKey = {
+  xpub: string;
+  path: string;
+  accountIndex: number;
+  xpubSegwit?: string;
+  chainCode?: string;
+  publicKey?: string;
+  fingerprint?: number;
+  depth?: number;
+};
+
+export type HDWalletDiscoveryMethods = {
+  getExtendedPublicKey?: () =>
+    | Promise<string | HDWalletExtendedPublicKey | undefined>
+    | string
+    | HDWalletExtendedPublicKey
+    | undefined;
+  getExtendedPublicKeyInfo: (params?: HDWalletAccountParams) => Promise<HDWalletExtendedPublicKey | undefined>;
+  deriveAddressAtIndex: (params: HDWalletDeriveAddressParams) => Promise<HDWalletDerivedAddress | undefined>;
+  deriveAddresses: (params: HDWalletDeriveAddressesParams) => Promise<HDWalletDerivedAddress[]>;
+};
+
+export type SKWalletsSupportedChains = {
+  [WalletOption.BITGET]: typeof bitgetWallet.connectBitget.supportedChains;
+  [WalletOption.BRAVE]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet.connectCoinbaseWallet.supportedChains;
+  [WalletOption.COINBASE_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.COSMOSTATION]: typeof cosmostationWallet.connectCosmostation.supportedChains;
+  [WalletOption.CTRL]: typeof ctrlWallet.connectCtrl.supportedChains;
+  [WalletOption.EIP6963]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.EXODUS]: typeof passkeysWallet.connectPasskeys.supportedChains;
+  [WalletOption.KEEPKEY]: typeof keepkeyWallet.connectKeepkey.supportedChains;
+  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet.connectKeepkeyBex.supportedChains;
+  [WalletOption.KEPLR]: typeof keplrWallet.connectKeplr.supportedChains;
+  [WalletOption.KEYSTORE]: typeof keystoreWallet.connectKeystore.supportedChains;
+  [WalletOption.LEAP]: typeof keplrWallet.connectKeplr.supportedChains;
+  [WalletOption.LEDGER]: typeof ledgerWallet.connectLedger.supportedChains;
+  [WalletOption.METAMASK]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.OKX]: typeof okxWallet.connectOkx.supportedChains;
+  [WalletOption.OKX_MOBILE]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.ONEKEY]: typeof onekeyWallet.connectOnekeyWallet.supportedChains;
+  [WalletOption.PASSKEYS]: typeof passkeysWallet.connectPasskeys.supportedChains;
+  [WalletOption.PETRA]: typeof petraWallet.connectPetra.supportedChains;
+  [WalletOption.PHANTOM]: typeof phantomWallet.connectPhantom.supportedChains;
+  [WalletOption.POLKADOT_JS]: typeof polkadotWallet.connectPolkadotJs.supportedChains;
+  [WalletOption.RADIX_WALLET]: typeof radixWallet.connectRadixWallet.supportedChains;
+  [WalletOption.TALISMAN]: typeof talismanWallet.connectTalisman.supportedChains;
+  [WalletOption.TREZOR]: typeof trezorWallet.connectTrezor.supportedChains;
+  [WalletOption.TRONLINK]: typeof tronlinkWallet.connectTronLink.supportedChains;
+  [WalletOption.TRUSTWALLET_WEB]: typeof trustwalletWallet.connectTrustWallet.supportedChains;
+  [WalletOption.VULTISIG]: typeof vultisigWallet.connectVultisig.supportedChains;
+  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
+  [WalletOption.WALLET_SELECTOR]: typeof walletSelectorWallet.connectWalletSelector.supportedChains;
+  [WalletOption.XAMAN]: typeof xamanWallet.connectXaman.supportedChains;
+};

package/src/utils.ts

@@ -0,0 +1,58 @@
+import { WalletOption } from "@swapkit/helpers";
+import type { SKWallets } from "./types";
+
+export async function loadWallet<W extends WalletOption>(walletOption: W): Promise<SKWallets[W]> {
+  const { match } = await import("ts-pattern");
+
+  const wallet = await match(walletOption as WalletOption)
+    .with(WalletOption.COINBASE_MOBILE, async () => (await import("./coinbase")).coinbaseWallet)
+    .with(WalletOption.BITGET, async () => (await import("@swapkit/wallet-extensions/bitget")).bitgetWallet)
+    .with(WalletOption.CTRL, async () => (await import("@swapkit/wallet-extensions/ctrl")).ctrlWallet)
+    .with(WalletOption.VULTISIG, async () => (await import("@swapkit/wallet-extensions/vultisig")).vultisigWallet)
+    .with(WalletOption.OKX, async () => (await import("@swapkit/wallet-extensions/okx")).okxWallet)
+    .with(WalletOption.ONEKEY, async () => (await import("@swapkit/wallet-extensions/onekey")).onekeyWallet)
+    .with(WalletOption.EXODUS, async () => (await import("./passkeys")).passkeysWallet)
+    .with(WalletOption.KEEPKEY, async () => (await import("@swapkit/wallet-hardware/keepkey")).keepkeyWallet)
+    .with(
+      WalletOption.KEEPKEY_BEX,
+      async () => (await import("@swapkit/wallet-extensions/keepkey-bex")).keepkeyBexWallet,
+    )
+    .with(WalletOption.WALLETCONNECT, async () => (await import("./walletconnect")).walletconnectWallet)
+    .with(
+      WalletOption.KEPLR,
+      WalletOption.LEAP,
+      async () => (await import("@swapkit/wallet-extensions/keplr")).keplrWallet,
+    )
+    .with(
+      WalletOption.COSMOSTATION,
+      async () => (await import("@swapkit/wallet-extensions/cosmostation")).cosmostationWallet,
+    )
+    .with(
+      WalletOption.BRAVE,
+      WalletOption.COINBASE_WEB,
+      WalletOption.EIP6963,
+      WalletOption.METAMASK,
+      WalletOption.OKX_MOBILE,
+      async () => (await import("@swapkit/wallet-extensions/evm-extensions")).evmWallet,
+    )
+    .with(
+      WalletOption.TRUSTWALLET_WEB,
+      async () => (await import("@swapkit/wallet-extensions/trustwallet")).trustwalletWallet,
+    )
+
+    .with(WalletOption.KEYSTORE, async () => (await import("./keystore")).keystoreWallet)
+    .with(WalletOption.TREZOR, async () => (await import("@swapkit/wallet-hardware/trezor")).trezorWallet)
+    .with(WalletOption.LEDGER, async () => (await import("@swapkit/wallet-hardware/ledger")).ledgerWallet)
+    .with(WalletOption.PASSKEYS, async () => (await import("./passkeys")).passkeysWallet)
+    .with(WalletOption.PETRA, async () => (await import("@swapkit/wallet-extensions/petra")).petraWallet)
+    .with(WalletOption.PHANTOM, async () => (await import("@swapkit/wallet-extensions/phantom")).phantomWallet)
+    .with(WalletOption.POLKADOT_JS, async () => (await import("@swapkit/wallet-extensions/polkadotjs")).polkadotWallet)
+    .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
+    .with(WalletOption.TALISMAN, async () => (await import("@swapkit/wallet-extensions/talisman")).talismanWallet)
+    .with(WalletOption.TRONLINK, async () => (await import("@swapkit/wallet-extensions/tronlink")).tronlinkWallet)
+    .with(WalletOption.WALLET_SELECTOR, async () => (await import("./near-wallet-selector")).walletSelectorWallet)
+    .with(WalletOption.XAMAN, async () => (await import("./xaman")).xamanWallet)
+    .exhaustive();
+
+  return wallet as SKWallets[W];
+}

package/src/vultisig.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/vultisig";

package/src/walletconnect/constants.ts

@@ -0,0 +1,105 @@
+import type { ClientMetadata } from "./types";
+
+export const DEFAULT_RELAY_URL = "wss://relay.walletconnect.com";
+
+export const ETHEREUM_MAINNET_ID = "eip155:1";
+export const BSC_MAINNET_ID = "eip155:56";
+export const AVALANCHE_MAINNET_ID = "eip155:43114";
+export const THORCHAIN_MAINNET_ID = "cosmos:thorchain";
+export const COSMOS_HUB_MAINNET_ID = "cosmos:cosmoshub-4";
+export const KUJIRA_MAINNET_ID = "cosmos:kaiyo-1";
+export const MAYACHAIN_MAINNET_ID = "cosmos:mayachain-mainnet-v1";
+export const ARBITRUM_ONE_MAINNET_ID = "eip155:42161";
+export const OPTIMISM_MAINNET_ID = "eip155:10";
+export const POLYGON_MAINNET_ID = "eip155:137";
+export const BASE_MAINNET_ID = "eip155:8453";
+export const NEAR_MAINNET_ID = "near:mainnet";
+export const NEAR_TESTNET_ID = "near:testnet";
+export const TRON_MAINNET_ID = "tron:0x2b6653dc";
+export const AURORA_MAINNET_ID = "eip155:1313161554";
+export const BERACHAIN_MAINNET_ID = "eip155:80094";
+export const MONAD_MAINNET_ID = "eip155:143";
+export const XLAYER_MAINNET_ID = "eip155:196";
+
+export const DEFAULT_LOGGER = "debug";
+
+export const DEFAULT_APP_METADATA: ClientMetadata = {
+  description: "SwapKit cross-chain SDK",
+  icons: ["https://raw.githubusercontent.com/swapkit/SwapKit/refs/heads/develop/docs/src/assets/logo-black.png"],
+  name: "SwapKit",
+  url: "https://swapkit.dev/",
+};
+
+/**
+ * EIP155
+ */
+export enum DEFAULT_EIP155_METHODS {
+  ETH_SEND_TRANSACTION = "eth_sendTransaction",
+  // not supported by most WC wallets
+  // ETH_SIGN_TRANSACTION = 'eth_signTransaction',
+  ETH_SIGN = "eth_sign",
+  PERSONAL_SIGN = "personal_sign",
+  ETH_SIGN_TYPED_DATA = "eth_signTypedData",
+  ETH_SIGN_TYPED_DATA_V4 = "eth_signTypedData_v4",
+}
+
+export enum DEFAULT_EIP_155_EVENTS {
+  ETH_CHAIN_CHANGED = "chainChanged",
+  ETH_ACCOUNTS_CHANGED = "accountsChanged",
+}
+
+/**
+ * COSMOS
+ */
+export enum DEFAULT_COSMOS_METHODS {
+  COSMOS_SIGN_DIRECT = "cosmos_signDirect",
+  COSMOS_SIGN_AMINO = "cosmos_signAmino",
+  COSMOS_GET_ACCOUNTS = "cosmos_getAccounts",
+}
+
+export enum DEFAULT_COSMOS_EVENTS {}
+
+/**
+ * SOLANA
+ */
+export enum DEFAULT_SOLANA_METHODS {
+  SOL_SIGN_TRANSACTION = "solana_signTransaction",
+  SOL_SIGN_MESSAGE = "solana_signMessage",
+}
+
+export enum DEFAULT_SOLANA_EVENTS {}
+
+/**
+ * POLKADOT
+ */
+export enum DEFAULT_POLKADOT_METHODS {
+  POLKADOT_SIGN_TRANSACTION = "polkadot_signTransaction",
+  POLKADOT_SIGN_MESSAGE = "polkadot_signMessage",
+}
+
+export enum DEFAULT_POLKADOT_EVENTS {}
+
+/**
+ * NEAR
+ */
+export enum DEFAULT_NEAR_METHODS {
+  NEAR_SIGN_IN = "near_signIn",
+  NEAR_SIGN_OUT = "near_signOut",
+  NEAR_GET_ACCOUNTS = "near_getAccounts",
+  NEAR_SIGN_AND_SEND_TRANSACTION = "near_signAndSendTransaction",
+  NEAR_SIGN_AND_SEND_TRANSACTIONS = "near_signAndSendTransactions",
+}
+
+export enum DEFAULT_NEAR_EVENTS {}
+
+/**
+ * TRON
+ */
+export enum DEFAULT_TRON_METHODS {
+  TRON_SIGN_MESSAGE = "tron_signMessage",
+  TRON_SIGN_TRANSACTION = "tron_signTransaction",
+  TRON_SEND_TRANSACTION = "tron_sendTransaction",
+  TRON_GET_ACCOUNTS = "tron_getAccounts",
+}
+
+export enum DEFAULT_TRON_EVENTS {}

package/src/walletconnect/evmSigner.ts

@@ -0,0 +1,116 @@
+import { type EVMChain, SwapKitError, WalletOption } from "@swapkit/helpers";
+import type {
+  JsonRpcProvider,
+  Provider,
+  TransactionRequest,
+  TransactionResponse,
+  TypedDataDomain,
+  TypedDataField,
+} from "ethers";
+import { AbstractSigner } from "ethers";
+
+import { DEFAULT_EIP155_METHODS } from "./constants";
+import { chainToChainId, getAddressByChain } from "./helpers";
+import type { Walletconnect } from "./index";
+
+interface WalletconnectEVMSignerParams {
+  chain: EVMChain;
+  walletconnect: Walletconnect;
+  provider: Provider | JsonRpcProvider;
+}
+
+class WalletconnectSigner extends AbstractSigner {
+  address: string;
+
+  private chain: EVMChain;
+  private walletconnect: Walletconnect;
+  readonly provider: Provider | JsonRpcProvider;
+
+  constructor({ chain, provider, walletconnect }: WalletconnectEVMSignerParams) {
+    super(provider);
+    this.chain = chain;
+    this.walletconnect = walletconnect;
+    this.provider = provider;
+    this.address = "";
+  }
+
+  // biome-ignore lint/suspicious/useAwait: fulfil implementation type
+  getAddress = async () => {
+    if (!this.walletconnect) {
+      throw new SwapKitError("wallet_walletconnect_connection_not_established");
+    }
+    if (!this.address) {
+      this.address = getAddressByChain(this.chain, this.walletconnect.accounts || []);
+    }
+
+    return this.address;
+  };
+
+  signMessage = async (message: string) => {
+    // this is probably broken
+    const txHash = (await this.walletconnect?.client.request({
+      chainId: chainToChainId(this.chain),
+      request: { method: DEFAULT_EIP155_METHODS.ETH_SIGN, params: [message] },
+      topic: this.walletconnect.session.topic || "",
+    })) as string;
+
+    return txHash.startsWith("0x") ? txHash : `0x${txHash}`;
+  };
+
+  signTransaction = () => {
+    throw new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signTransaction" });
+
+    // const baseTx = {
+    //   from,
+    //   to,
+    //   value: BigNumber.from(value || 0).toHexString(),
+    //   data,
+    // };
+
+    // const txHash = (await this.walletconnect?.client.request({
+    //   chainId: chainToChainId(this.chain),
+    //   topic: this.walletconnect.session.topic,
+    //   request: {
+    //     method: DEFAULT_EIP155_METHODS.ETH_SIGN_TRANSACTION,
+    //     params: [baseTx],
+    //   },
+    // })) as string;
+
+    // return txHash.startsWith('0x') ? txHash : `0x${txHash}`;
+  };
+
+  signTypedData = (
+    _domain: TypedDataDomain,
+    _types: Record<string, TypedDataField[]>,
+    _value: Record<string, unknown>,
+    _explicitPrimaryType?: string,
+  ) => {
+    throw new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signTransaction" });
+  };
+
+  sendTransaction = async ({ from, to, value, data }: TransactionRequest) => {
+    const { toHexString } = await import("@swapkit/toolboxes/evm");
+
+    const baseTx = { data, from, to, value: toHexString(BigInt(value || 0)) };
+    const response = await this.walletconnect?.client.request({
+      chainId: chainToChainId(this.chain),
+      request: { method: DEFAULT_EIP155_METHODS.ETH_SEND_TRANSACTION, params: [baseTx] },
+      topic: this.walletconnect.session.topic,
+    });
+
+    return response as TransactionResponse;
+  };
+
+  connect = (provider: Provider | null) => {
+    if (!provider) {
+      throw new SwapKitError({
+        errorKey: "wallet_provider_not_found",
+        info: { chain: this.chain, wallet: WalletOption.WALLETCONNECT },
+      });
+    }
+
+    return new WalletconnectSigner({ chain: this.chain, provider, walletconnect: this.walletconnect });
+  };
+}
+export const getEVMSigner = async ({ chain, walletconnect, provider }: WalletconnectEVMSignerParams) =>
+  new WalletconnectSigner({ chain, provider, walletconnect });

package/src/walletconnect/helpers.ts

@@ -0,0 +1,76 @@
+import { Chain, type CosmosChain, type EVMChain, SKConfig } from "@swapkit/helpers";
+
+import {
+  ARBITRUM_ONE_MAINNET_ID,
+  AURORA_MAINNET_ID,
+  AVALANCHE_MAINNET_ID,
+  BASE_MAINNET_ID,
+  BERACHAIN_MAINNET_ID,
+  BSC_MAINNET_ID,
+  COSMOS_HUB_MAINNET_ID,
+  ETHEREUM_MAINNET_ID,
+  KUJIRA_MAINNET_ID,
+  MAYACHAIN_MAINNET_ID,
+  MONAD_MAINNET_ID,
+  NEAR_MAINNET_ID,
+  NEAR_TESTNET_ID,
+  OPTIMISM_MAINNET_ID,
+  POLYGON_MAINNET_ID,
+  THORCHAIN_MAINNET_ID,
+  TRON_MAINNET_ID,
+  XLAYER_MAINNET_ID,
+} from "./constants";
+
+export const getAddressByChain = (
+  chain: EVMChain | Exclude<CosmosChain, typeof Chain.Noble> | typeof Chain.Near | typeof Chain.Tron,
+  accounts: string[],
+) => {
+  const account = accounts.find((account) => account.startsWith(chainToChainId(chain))) || "";
+  const address = account?.split(":")?.[2];
+
+  return address || "";
+};
+
+export const chainToChainId = (chain: Chain) => {
+  switch (chain) {
+    case Chain.Avalanche:
+      return AVALANCHE_MAINNET_ID;
+    case Chain.Aurora:
+      return AURORA_MAINNET_ID;
+    case Chain.Base:
+      return BASE_MAINNET_ID;
+    case Chain.BinanceSmartChain:
+      return BSC_MAINNET_ID;
+    case Chain.Berachain:
+      return BERACHAIN_MAINNET_ID;
+    case Chain.Monad:
+      return MONAD_MAINNET_ID;
+    case Chain.Ethereum:
+      return ETHEREUM_MAINNET_ID;
+    case Chain.THORChain:
+      return THORCHAIN_MAINNET_ID;
+    case Chain.Arbitrum:
+      return ARBITRUM_ONE_MAINNET_ID;
+    case Chain.Optimism:
+      return OPTIMISM_MAINNET_ID;
+    case Chain.Polygon:
+      return POLYGON_MAINNET_ID;
+    case Chain.Maya:
+      return MAYACHAIN_MAINNET_ID;
+    case Chain.Cosmos:
+      return COSMOS_HUB_MAINNET_ID;
+    case Chain.Kujira:
+      return KUJIRA_MAINNET_ID;
+    case Chain.Near: {
+      // Use testnet if stagenet is enabled
+      const { isStagenet } = SKConfig.get("envs");
+      return isStagenet ? NEAR_TESTNET_ID : NEAR_MAINNET_ID;
+    }
+    case Chain.Tron:
+      return TRON_MAINNET_ID;
+    case Chain.XLayer:
+      return XLAYER_MAINNET_ID;
+    default:
+      return "";
+  }
+};