@sodax/wallet-sdk-react 1.5.7-beta → 2.0.0-rc.10

package/dist/chunk-WPZOLGVB.mjs

@@ -0,0 +1,148 @@
+import { assert, isRecord, hasBooleanProperty } from './chunk-TACW7Z4D.mjs';
+import { WALLET_METADATA } from './chunk-NAKCAL2M.mjs';
+import { isNativeToken } from './chunk-7V7O3Q7Y.mjs';
+import { XService, XConnector } from './chunk-IFXZQW4C.mjs';
+import * as IconSdkRaw from 'icon-sdk-js';
+
+var IconSdk = "default" in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw;
+var { IconService: IconServiceConstructor, Builder: IconBuilder, Converter: IconConverter } = IconSdk;
+var SupportedChainId = /* @__PURE__ */ ((SupportedChainId2) => {
+  SupportedChainId2[SupportedChainId2["MAINNET"] = 1] = "MAINNET";
+  return SupportedChainId2;
+})(SupportedChainId || {});
+var CHAIN_INFO = {
+  [1 /* MAINNET */]: {
+    name: "ICON Mainnet",
+    node: "https://ctz.solidwallet.io",
+    APIEndpoint: "https://ctz.solidwallet.io/api/v3",
+    debugAPIEndpoint: "https://api.icon.community/api/v3d",
+    chainId: 1,
+    tracker: "https://tracker.icon.community"
+  }
+};
+var IconXService = class _IconXService extends XService {
+  static instance;
+  iconService;
+  constructor(rpcUrl) {
+    super("ICON");
+    const mainnetInfo = CHAIN_INFO[1 /* MAINNET */];
+    if (!mainnetInfo) throw new Error("ICON mainnet chain info not found");
+    this.iconService = new IconServiceConstructor(
+      new IconServiceConstructor.HttpProvider(rpcUrl ?? mainnetInfo.APIEndpoint)
+    );
+  }
+  static getInstance(rpcUrl) {
+    if (!_IconXService.instance) {
+      _IconXService.instance = new _IconXService(rpcUrl);
+    }
+    return _IconXService.instance;
+  }
+  async getAggregateData(requireSuccess, calls) {
+    const rawTx = new IconBuilder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls }).build();
+    try {
+      const result = await this.iconService.call(rawTx).execute();
+      const aggs = result["returnData"];
+      const data = aggs.map((agg) => {
+        if (agg["success"] === "0x0") {
+          return null;
+        }
+        return agg["returnData"];
+      });
+      return data;
+    } catch (err) {
+      console.error(err);
+      return Array(calls.length).fill(null);
+    }
+  }
+  async getBalances(address, xTokens) {
+    if (!address) return {};
+    const balances = {};
+    const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
+    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
+    if (nativeXToken) {
+      const balance = await this.iconService.getBalance(address).execute();
+      balances[nativeXToken.address] = BigInt(balance.toFixed());
+    }
+    const cds = nonNativeXTokens.map((token) => {
+      return {
+        target: token.address,
+        method: "balanceOf",
+        params: [address]
+      };
+    });
+    const data = await this.getAggregateData(
+      false,
+      cds.filter((cd) => cd.target.startsWith("cx"))
+    );
+    return nonNativeXTokens.reduce((agg, token, idx) => {
+      const balance = data[idx];
+      if (balance) {
+        balances[token.address] = BigInt(balance);
+      }
+      return agg;
+    }, balances);
+  }
+};
+
+// src/xchains/icon/iconex/index.tsx
+var ICONEX_RELAY_RESPONSE = "ICONEX_RELAY_RESPONSE";
+var ICONEX_RELAY_REQUEST = "ICONEX_RELAY_REQUEST";
+var request = (event) => {
+  return new Promise((resolve, reject) => {
+    const handler = (evt) => {
+      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
+      resolve(evt.detail);
+    };
+    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
+    window.dispatchEvent(
+      new CustomEvent(ICONEX_RELAY_REQUEST, {
+        detail: event
+      })
+    );
+  });
+};
+
+// src/xchains/icon/IconHanaXConnector.ts
+var isHanaWallet = (value) => {
+  return isRecord(value) && (value.available === void 0 || hasBooleanProperty(value, "available"));
+};
+var IconHanaXConnector = class extends XConnector {
+  constructor() {
+    super("ICON", "Hana Wallet", "hana");
+  }
+  get isInstalled() {
+    if (typeof window === "undefined") return false;
+    const hanaWallet = window.hanaWallet;
+    return isHanaWallet(hanaWallet) && hanaWallet.available === true;
+  }
+  get installUrl() {
+    return WALLET_METADATA.hana.installUrl;
+  }
+  async connect() {
+    const hanaWallet = window.hanaWallet;
+    assert(isHanaWallet(hanaWallet) || hanaWallet === void 0, "[IconHanaXConnector] invalid window.hanaWallet type");
+    if (!hanaWallet || !hanaWallet.available) {
+      window.open(WALLET_METADATA.hana.installUrl, "_blank", "noopener,noreferrer");
+      return;
+    }
+    const detail = await request({
+      type: "REQUEST_ADDRESS" /* REQUEST_ADDRESS */
+    });
+    if (detail?.type === "RESPONSE_ADDRESS" /* RESPONSE_ADDRESS */) {
+      return {
+        address: detail?.payload,
+        xChainType: this.xChainType
+      };
+    }
+    console.warn("[IconHanaXConnector] connect: unexpected response from Hana wallet", detail);
+    return void 0;
+  }
+  async disconnect() {
+    console.log("HanaIconXConnector disconnected");
+  }
+  get icon() {
+    return WALLET_METADATA.hana.icon;
+  }
+};
+
+export { CHAIN_INFO, IconHanaXConnector, IconXService, SupportedChainId, request };

package/dist/chunk-X7BHR7WS.mjs

@@ -0,0 +1,200 @@
+import { STELLAR_DEFAULT_HORIZON_RPC_URL, STELLAR_DEFAULT_SOROBAN_RPC_URL } from './chunk-NAKCAL2M.mjs';
+import { XService, XConnector } from './chunk-IFXZQW4C.mjs';
+import { StellarWalletsKit, WalletNetwork, allowAllModules } from '@creit.tech/stellar-wallets-kit';
+import * as StellarSdk from '@stellar/stellar-sdk';
+import { rpc, Contract, TimeoutInfinite, scValToBigInt, Address } from '@stellar/stellar-sdk';
+
+var CustomSorobanServer = class extends rpc.Server {
+  customHeaders;
+  constructor(serverUrl, customHeaders) {
+    super(serverUrl, {
+      allowHttp: true
+    });
+    this.customHeaders = customHeaders;
+  }
+  async simulateTransaction(tx) {
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.customHeaders
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "simulateTransaction",
+        params: {
+          transaction: tx.toXDR()
+        }
+      })
+    };
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error simulating TX! status: ${response.status}`);
+    }
+    return response.json().then((json) => rpc.parseRawSimulation(json.result));
+  }
+  async sendTransaction(tx) {
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.customHeaders
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "sendTransaction",
+        params: {
+          transaction: tx.toXDR()
+        }
+      })
+    };
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error submitting TX! status: ${response.status}`);
+    }
+    return response.json().then((json) => json.result);
+  }
+  async getTransaction(hash) {
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.customHeaders
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "getTransaction",
+        params: { hash }
+      })
+    };
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error getting TX! status: ${response.status}`);
+    }
+    return response.json().then((json) => json.result);
+  }
+};
+var CustomSorobanServer_default = CustomSorobanServer;
+var accountToScVal = (account) => new Address(account).toScVal();
+var simulateTx = (tx, server) => server.simulateTransaction(tx);
+var getTokenBalance = async (address, tokenId, txBuilder, server) => {
+  const params = [accountToScVal(address)];
+  const contract = new Contract(tokenId);
+  const tx = txBuilder.addOperation(contract.call("balance", ...params)).setTimeout(TimeoutInfinite).build();
+  const result = await simulateTx(tx, server);
+  if (!rpc.Api.isSimulationSuccess(result)) {
+    throw new Error(`Simulation failed: ${JSON.stringify(result)}`);
+  }
+  return result.result ? scValToBigInt(result.result.retval) : 0n;
+};
+
+// src/xchains/stellar/StellarXService.ts
+var STELLAR_BASE_RESERVE_STROOPS = 5e6;
+function parseXlmBalanceToStroops(balanceStr) {
+  const parts = balanceStr.split(".");
+  const whole = parts[0] ?? "0";
+  const frac = (parts[1] ?? "").padEnd(7, "0").slice(0, 7);
+  return BigInt(whole + frac);
+}
+var StellarXService = class _StellarXService extends XService {
+  static instance;
+  walletsKit;
+  server;
+  sorobanServer;
+  constructor(horizonRpcUrl, sorobanRpcUrl) {
+    super("STELLAR");
+    this.walletsKit = new StellarWalletsKit({
+      network: WalletNetwork.PUBLIC,
+      modules: allowAllModules()
+    });
+    this.server = new StellarSdk.Horizon.Server(horizonRpcUrl ?? STELLAR_DEFAULT_HORIZON_RPC_URL, { allowHttp: true });
+    this.sorobanServer = new CustomSorobanServer_default(sorobanRpcUrl ?? STELLAR_DEFAULT_SOROBAN_RPC_URL, {});
+  }
+  static getInstance(horizonRpcUrl, sorobanRpcUrl) {
+    if (!_StellarXService.instance) {
+      _StellarXService.instance = new _StellarXService(horizonRpcUrl, sorobanRpcUrl);
+    } else {
+      if (horizonRpcUrl) {
+        _StellarXService.instance.server = new StellarSdk.Horizon.Server(horizonRpcUrl, { allowHttp: true });
+      }
+      if (sorobanRpcUrl) {
+        _StellarXService.instance.sorobanServer = new CustomSorobanServer_default(sorobanRpcUrl, {});
+      }
+    }
+    return _StellarXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return BigInt(0);
+    const stellarAccount = await this.server.loadAccount(address);
+    if (xToken.symbol === "XLM") {
+      const xlmBalance = stellarAccount.balances.find((balance) => balance.asset_type === "native");
+      if (xlmBalance) {
+        const rawBalanceStroops = parseXlmBalanceToStroops(xlmBalance.balance);
+        const sellingLiabilitiesStroops = xlmBalance.selling_liabilities ? parseXlmBalanceToStroops(xlmBalance.selling_liabilities) : BigInt(0);
+        const reserveFields = stellarAccount;
+        const subentryCount = reserveFields.subentry_count ?? 0;
+        const numSponsoring = reserveFields.num_sponsoring ?? 0;
+        const numSponsored = reserveFields.num_sponsored ?? 0;
+        const reserveCount = Math.max(0, 2 + subentryCount + numSponsoring - numSponsored);
+        const minBalanceStroops = BigInt(reserveCount) * BigInt(STELLAR_BASE_RESERVE_STROOPS) + sellingLiabilitiesStroops;
+        const availableStroops = rawBalanceStroops > minBalanceStroops ? rawBalanceStroops - minBalanceStroops : BigInt(0);
+        return availableStroops;
+      }
+    } else {
+      try {
+        const txBuilder = new StellarSdk.TransactionBuilder(stellarAccount, {
+          fee: StellarSdk.BASE_FEE,
+          networkPassphrase: StellarSdk.Networks.PUBLIC
+        });
+        const balance = await getTokenBalance(address, xToken.address, txBuilder, this.sorobanServer);
+        return balance;
+      } catch (e) {
+        console.error(`Error while fetching token on Stellar: ${xToken.symbol}, Error: ${e}`);
+      }
+    }
+    return BigInt(0);
+  }
+};
+
+// src/xchains/stellar/StellarWalletsKitXConnector.ts
+var StellarWalletsKitXConnector = class extends XConnector {
+  _wallet;
+  constructor(wallet) {
+    super("STELLAR", wallet.name, wallet.id);
+    this._wallet = wallet;
+  }
+  getXService() {
+    return StellarXService.getInstance();
+  }
+  async connect() {
+    const kit = this.getXService().walletsKit;
+    if (!this._wallet) {
+      return;
+    }
+    if (!this._wallet.isAvailable) {
+      throw new Error(`${this._wallet.name} is not installed. Install the wallet and reload the page.`);
+    }
+    kit.setWallet(this._wallet.id);
+    const { address } = await kit.getAddress();
+    return {
+      address,
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+  }
+  get icon() {
+    return this._wallet.icon;
+  }
+  get isInstalled() {
+    return this._wallet.isAvailable;
+  }
+  get installUrl() {
+    return this._wallet.url;
+  }
+};
+
+export { StellarWalletsKitXConnector, StellarXService };

package/dist/chunk-Z5GXDHGL.mjs

@@ -0,0 +1,190 @@
+import { getRpcUrl, getWagmiChainId, isNativeToken } from './chunk-7V7O3Q7Y.mjs';
+import { XService, XConnector } from './chunk-IFXZQW4C.mjs';
+import { ChainKeys } from '@sodax/types';
+import { erc20Abi, defineChain } from 'viem';
+import { getPublicClient } from 'wagmi/actions';
+import { createConfig, createStorage, cookieStorage, http } from 'wagmi';
+import { mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, lightlinkPhoenix, kaia, redbellyMainnet } from 'wagmi/chains';
+
+var hyper = /* @__PURE__ */ defineChain({
+  id: 999,
+  name: "HyperEVM",
+  nativeCurrency: {
+    decimals: 18,
+    name: "HYPE",
+    symbol: "HYPE"
+  },
+  rpcUrls: {
+    default: { http: ["https://rpc.hyperliquid.xyz/evm"] }
+  },
+  blockExplorers: {
+    default: {
+      name: "HyperEVMScan",
+      url: "https://hyperevmscan.io/"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 13051
+    }
+  }
+});
+var createWagmiConfig = (evmChains, options) => {
+  return createConfig({
+    chains: [
+      mainnet,
+      avalanche,
+      arbitrum,
+      base,
+      bsc,
+      sonic,
+      optimism,
+      polygon,
+      hyper,
+      lightlinkPhoenix,
+      kaia,
+      redbellyMainnet
+    ],
+    connectors: options?.connectors ?? [],
+    // NOTE: wagmi's `ssr` is a hydration-timing flag, not an "is host app SSR"
+    // flag. `true` defers `Hydrate.onMount()` into `useEffect` (safe for both
+    // CSR and SSR); `false` runs it in render and trips React's "setState
+    // during render" warning on subscribers like `EvmHydrator`. Default to
+    // `true` so direct callers of `createWagmiConfig` stay safe — only pass
+    // `false` if you have a specific reason. See issue #129.
+    ssr: options?.ssr ?? true,
+    transports: {
+      [mainnet.id]: http(getRpcUrl(evmChains?.[ChainKeys.ETHEREUM_MAINNET])),
+      [avalanche.id]: http(getRpcUrl(evmChains?.[ChainKeys.AVALANCHE_MAINNET])),
+      [arbitrum.id]: http(getRpcUrl(evmChains?.[ChainKeys.ARBITRUM_MAINNET])),
+      [base.id]: http(getRpcUrl(evmChains?.[ChainKeys.BASE_MAINNET])),
+      [bsc.id]: http(getRpcUrl(evmChains?.[ChainKeys.BSC_MAINNET])),
+      [sonic.id]: http(getRpcUrl(evmChains?.[ChainKeys.SONIC_MAINNET])),
+      [optimism.id]: http(getRpcUrl(evmChains?.[ChainKeys.OPTIMISM_MAINNET])),
+      [polygon.id]: http(getRpcUrl(evmChains?.[ChainKeys.POLYGON_MAINNET])),
+      [hyper.id]: http(getRpcUrl(evmChains?.[ChainKeys.HYPEREVM_MAINNET])),
+      [lightlinkPhoenix.id]: http(getRpcUrl(evmChains?.[ChainKeys.LIGHTLINK_MAINNET])),
+      [redbellyMainnet.id]: http(getRpcUrl(evmChains?.[ChainKeys.REDBELLY_MAINNET])),
+      [kaia.id]: http(getRpcUrl(evmChains?.[ChainKeys.KAIA_MAINNET]))
+    },
+    storage: createStorage({
+      storage: cookieStorage,
+      key: "sodax"
+    })
+  });
+};
+var EvmXService = class _EvmXService extends XService {
+  static instance;
+  wagmiConfig;
+  constructor() {
+    super("EVM");
+  }
+  static getInstance() {
+    if (!_EvmXService.instance) {
+      _EvmXService.instance = new _EvmXService();
+    }
+    return _EvmXService.instance;
+  }
+  // get erc20 token balance in a chain (evm chain only)
+  async _getTokenBalance(address, chainId, tokenAddress) {
+    const publicClient = getPublicClient(this.wagmiConfig, { chainId });
+    if (!publicClient) throw new Error("Public client not found");
+    const balance = await publicClient.readContract({
+      abi: erc20Abi,
+      address: tokenAddress,
+      functionName: "balanceOf",
+      args: [address]
+    });
+    return balance || 0n;
+  }
+  //get native balance of the chain (evm chain only)
+  async _getChainBalance(address, chainId) {
+    const balance = await getPublicClient(this.wagmiConfig, { chainId })?.getBalance({
+      address
+    });
+    return balance || 0n;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    if (!this.wagmiConfig) return 0n;
+    const chainId = getWagmiChainId(xToken.chainKey);
+    if (isNativeToken(xToken)) {
+      return this._getChainBalance(address, chainId);
+    }
+    throw new Error(`Unsupported token: ${xToken.symbol}`);
+  }
+  async getBalances(address, xTokens) {
+    if (!address) return {};
+    if (!this.wagmiConfig) return {};
+    const nativeTokenBalancePromises = xTokens.filter((xToken) => isNativeToken(xToken)).map(async (xToken) => {
+      const balance = await this.getBalance(address, xToken);
+      return { symbol: xToken.symbol, address: xToken.address, balance };
+    });
+    const nativeTokenBalances = await Promise.all(nativeTokenBalancePromises);
+    const tokenMap = nativeTokenBalances.reduce(
+      (map, { address: address2, balance }) => {
+        if (balance) map[address2] = balance;
+        return map;
+      },
+      {}
+    );
+    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
+    const firstToken = xTokens[0];
+    if (!firstToken) return tokenMap;
+    const chainKey = firstToken.chainKey;
+    const viemChain = this.wagmiConfig.chains.find((chain) => chain.id === getWagmiChainId(chainKey));
+    const chainId = getWagmiChainId(chainKey);
+    const publicClient = getPublicClient(this.wagmiConfig, { chainId });
+    if (!publicClient) throw new Error("Public client not found");
+    if (viemChain?.contracts?.multicall3) {
+      const result = await publicClient.multicall({
+        contracts: nonNativeXTokens.map((token) => ({
+          abi: erc20Abi,
+          address: token.address,
+          functionName: "balanceOf",
+          args: [address]
+        }))
+      });
+      return nonNativeXTokens.reduce((acc, token, index) => {
+        const resultValue = result?.[index]?.result;
+        acc[token.address] = resultValue !== void 0 && resultValue !== null ? BigInt(resultValue) : 0n;
+        return acc;
+      }, tokenMap);
+    }
+    const nonNativeTokenBalances = await Promise.all(
+      nonNativeXTokens.map((token) => this._getTokenBalance(address, chainId, token.address))
+    );
+    return nonNativeXTokens.reduce((acc, token, idx) => {
+      acc[token.address] = nonNativeTokenBalances[idx] ?? 0n;
+      return acc;
+    }, tokenMap);
+  }
+};
+
+// src/xchains/evm/EvmXConnector.ts
+var WALLETCONNECT_ICON = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='32' height='32' viewBox='0 0 32 32'%3E%3Cpath fill='%233B99FC' d='M9.58 11.58c3.55-3.47 9.29-3.47 12.84 0l.43.42a.44.44 0 0 1 0 .63l-1.46 1.43a.23.23 0 0 1-.32 0l-.59-.57a6.72 6.72 0 0 0-9.36 0l-.63.61a.23.23 0 0 1-.32 0L8.71 12.7a.44.44 0 0 1 0-.63l.87-.5Zm15.87 2.95 1.3 1.28a.44.44 0 0 1 0 .63l-5.87 5.74a.46.46 0 0 1-.64 0l-4.17-4.08a.11.11 0 0 0-.16 0l-4.17 4.08a.46.46 0 0 1-.64 0l-5.87-5.74a.44.44 0 0 1 0-.63l1.3-1.28a.46.46 0 0 1 .64 0l4.17 4.08a.11.11 0 0 0 .16 0l4.17-4.08a.46.46 0 0 1 .64 0l4.17 4.08a.11.11 0 0 0 .16 0l4.17-4.08a.46.46 0 0 1 .64 0Z'/%3E%3C/svg%3E";
+var EvmXConnector = class extends XConnector {
+  connector;
+  constructor(connector) {
+    super("EVM", connector.name, connector.id);
+    this.connector = connector;
+  }
+  async connect() {
+    return;
+  }
+  async disconnect() {
+    return;
+  }
+  get id() {
+    return this.connector.id;
+  }
+  get icon() {
+    if (!this.connector.icon && this.connector.type === "walletConnect") {
+      return WALLETCONNECT_ICON;
+    }
+    return this.connector.icon;
+  }
+};
+
+export { EvmXConnector, EvmXService, createWagmiConfig };

package/dist/config-DEsqgrG1.d.ts

@@ -0,0 +1,151 @@
+import { BitcoinRpcConfig, ChainType, EvmChainKey, SolanaChainKey, SuiChainKey, IconChainKey, NearChainKey, StellarChainKey, StellarRpcConfig, BitcoinChainKey, InjectiveChainKey, InjectiveRpcConfig, StacksChainKey, StacksNetworkName, StacksNetworkLike, ChainKey, baseChainInfo } from '@sodax/types';
+import { BitcoinWalletDefaults, EvmWalletDefaults, SolanaWalletDefaults, SuiWalletDefaults, IconWalletDefaults, NearWalletDefaults, StellarWalletDefaults, InjectiveWalletDefaults, StacksWalletDefaults } from '@sodax/wallet-sdk-core';
+import { State } from 'wagmi';
+import { WalletConnectParameters } from 'wagmi/connectors';
+import { I as IXConnector } from './XConnector-12q0OVe5.js';
+
+type SimpleChainEntry<D> = {
+    rpcUrl?: string;
+    defaults?: D;
+};
+type EvmChainEntry = SimpleChainEntry<EvmWalletDefaults>;
+type SolanaChainEntry = SimpleChainEntry<SolanaWalletDefaults>;
+type SuiChainEntry = SimpleChainEntry<SuiWalletDefaults>;
+type IconChainEntry = SimpleChainEntry<IconWalletDefaults>;
+type NearChainEntry = SimpleChainEntry<NearWalletDefaults>;
+type StellarChainEntry = StellarRpcConfig & {
+    defaults?: StellarWalletDefaults;
+};
+type BitcoinChainEntry = BitcoinRpcConfig & {
+    defaults?: BitcoinWalletDefaults;
+};
+type InjectiveChainEntry = InjectiveRpcConfig & {
+    defaults?: InjectiveWalletDefaults;
+};
+type StacksChainEntry = StacksNetworkName | (StacksNetworkLike & {
+    defaults?: StacksWalletDefaults;
+});
+/** Wagmi-config-level settings shared across all configured EVM chains. */
+type EvmAdapterFields = {
+    /** Attempt to reconnect previously connected wallets on mount. @default false */
+    reconnectOnMount?: boolean;
+    /**
+     * wagmi hydration-timing flag (not an "app is SSR" flag).
+     * `true` defers wagmi reconnect into `useEffect`; `false` runs it in render
+     * and triggers React's "setState during render" warning. Keep `true` unless
+     * you know you need otherwise. @default true
+     */
+    ssr?: boolean;
+    /** Wagmi SSR hydration state — pass `cookieToInitialState()` to avoid disconnect flash on first load (Next.js only). */
+    initialState?: State;
+    /** WalletConnect configuration. Adds a WalletConnect connector when provided. */
+    walletConnect?: WalletConnectParameters;
+};
+/** `@solana/wallet-adapter-react` provider settings. */
+type SolanaAdapterFields = {
+    /** Auto-connect previously connected Solana wallet on mount. @default true */
+    autoConnect?: boolean;
+};
+/** `@mysten/dapp-kit` provider settings. */
+type SuiAdapterFields = {
+    autoConnect?: boolean;
+    /** Default network for the SuiClientProvider. @default 'mainnet' */
+    network?: 'mainnet' | 'testnet' | 'devnet';
+};
+/**
+ * Per-chain-type metadata — the only place that needs editing when adding a
+ * new chain type. Keys must match `ChainType`.
+ */
+type ChainMeta = {
+    EVM: {
+        keys: EvmChainKey;
+        entry: EvmChainEntry;
+        defaults: EvmWalletDefaults;
+        adapter: EvmAdapterFields;
+    };
+    SOLANA: {
+        keys: SolanaChainKey;
+        entry: SolanaChainEntry;
+        defaults: SolanaWalletDefaults;
+        adapter: SolanaAdapterFields;
+    };
+    SUI: {
+        keys: SuiChainKey;
+        entry: SuiChainEntry;
+        defaults: SuiWalletDefaults;
+        adapter: SuiAdapterFields;
+    };
+    ICON: {
+        keys: IconChainKey;
+        entry: IconChainEntry;
+        defaults: IconWalletDefaults;
+        adapter: {};
+    };
+    NEAR: {
+        keys: NearChainKey;
+        entry: NearChainEntry;
+        defaults: NearWalletDefaults;
+        adapter: {};
+    };
+    STELLAR: {
+        keys: StellarChainKey;
+        entry: StellarChainEntry;
+        defaults: StellarWalletDefaults;
+        adapter: {};
+    };
+    BITCOIN: {
+        keys: BitcoinChainKey;
+        entry: BitcoinChainEntry;
+        defaults: BitcoinWalletDefaults;
+        adapter: {};
+    };
+    INJECTIVE: {
+        keys: InjectiveChainKey;
+        entry: InjectiveChainEntry;
+        defaults: InjectiveWalletDefaults;
+        adapter: {};
+    };
+    STACKS: {
+        keys: StacksChainKey;
+        entry: StacksChainEntry;
+        defaults: StacksWalletDefaults;
+        adapter: {};
+    };
+};
+/** Resolves a `ChainKey` to its `ChainType` via the runtime `baseChainInfo` map. */
+type ChainTypeOf<K extends ChainKey> = (typeof baseChainInfo)[K]['type'];
+/**
+ * Flatten `A & B` into a single object type so TypeScript runs excess-property
+ * checks against the merged shape. Intersection types skip EPC, which lets
+ * unknown fields like `rpcUrl` slip into the EVM slot silently — flattening
+ * forces the check to fire on object literals.
+ */
+type Merge<A, B> = {
+    [K in keyof (A & B)]: (A & B)[K];
+};
+/** Per-chain-type slot shape — adapter fields + nested chain entries map. */
+type ChainTypeConfig<T extends ChainType> = Merge<ChainMeta[T]['adapter'], {
+    /** Optional connector overrides. If omitted, uses defaults from chainRegistry. */
+    connectors?: IXConnector[];
+    /** Per-chain-key entries — chain-specific RPC + wallet provider defaults. */
+    chains?: Partial<Record<ChainMeta[T]['keys'], ChainMeta[T]['entry']>>;
+}>;
+/** Per-chain-key entry shape — narrows by chain key via `baseChainInfo` lookup. */
+type ChainEntry<K extends ChainKey = ChainKey> = ChainMeta[ChainTypeOf<K>]['entry'];
+/** Wallet provider defaults shape for a given chain key. */
+type WalletDefaultsByKey<K extends ChainKey> = ChainMeta[ChainTypeOf<K>]['defaults'];
+type EvmTypeConfig = ChainTypeConfig<'EVM'>;
+type SolanaTypeConfig = ChainTypeConfig<'SOLANA'>;
+type SuiTypeConfig = ChainTypeConfig<'SUI'>;
+type BitcoinTypeConfig = ChainTypeConfig<'BITCOIN'>;
+type StellarTypeConfig = ChainTypeConfig<'STELLAR'>;
+type InjectiveTypeConfig = ChainTypeConfig<'INJECTIVE'>;
+type IconTypeConfig = ChainTypeConfig<'ICON'>;
+type NearTypeConfig = ChainTypeConfig<'NEAR'>;
+type StacksTypeConfig = ChainTypeConfig<'STACKS'>;
+/** Top-level config for `<SodaxWalletProvider>`. Omitted chain-type slots are not mounted. */
+type SodaxWalletConfig = {
+    [T in ChainType]?: ChainTypeConfig<T>;
+};
+
+export type { BitcoinChainEntry as B, ChainEntry as C, EvmAdapterFields as E, IconChainEntry as I, NearChainEntry as N, SodaxWalletConfig as S, WalletDefaultsByKey as W, BitcoinTypeConfig as a, ChainMeta as b, ChainTypeConfig as c, ChainTypeOf as d, EvmChainEntry as e, EvmTypeConfig as f, IconTypeConfig as g, InjectiveChainEntry as h, InjectiveTypeConfig as i, NearTypeConfig as j, SolanaAdapterFields as k, SolanaChainEntry as l, SolanaTypeConfig as m, StacksChainEntry as n, StacksTypeConfig as o, StellarChainEntry as p, StellarTypeConfig as q, SuiAdapterFields as r, SuiChainEntry as s, SuiTypeConfig as t };