@ariestools/sdk-react 10.0.2

package/dist/_pkg/crypto/browser/index.mjs

@@ -0,0 +1,2214 @@
+// src/components/EthAccount/EthAccountBox.tsx
+import { assertEx as assertEx2 } from "@ariestools/sdk";
+import { FlexRow as FlexRow2 } from "../../flexbox/browser/index.mjs";
+import { Identicon } from "../../identicon/browser/index.mjs";
+import {
+  Typography as Typography2,
+  useMediaQuery,
+  useTheme as useTheme2
+} from "@mui/material";
+import { EthAddressWrapper as EthAddressWrapper7 } from "@xylabs/eth-address";
+import { use as use2 } from "react";
+
+// src/contexts/Ethers/Context.ts
+import { createContext } from "react";
+var EthersContext = createContext({});
+
+// src/contexts/Ethers/Infura/Infura.tsx
+import { InfuraProvider } from "ethers/providers";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var infuraKey = "1d9f8053c65a49cfb99fafaa8ef201c0";
+var InfuraEthersLoader = (props) => {
+  const { children, enabled } = props;
+  void enabled;
+  const chainId = 1;
+  const value = useMemo(() => {
+    const provider = new InfuraProvider(1, infuraKey);
+    return {
+      busy: false,
+      chainId,
+      provider,
+      isConnected: false
+    };
+  }, [chainId]);
+  return /* @__PURE__ */ jsx(
+    EthersContext,
+    {
+      value,
+      children
+    }
+  );
+};
+
+// src/contexts/Ethers/Infura/use.tsx
+import { InfuraProvider as InfuraProvider2 } from "ethers/providers";
+import { useMemo as useMemo2 } from "react";
+var useInfuraProvider = (chainId) => {
+  const { provider, providerName } = useMemo2(() => {
+    const provider2 = new InfuraProvider2(chainId, infuraKey);
+    const providerName2 = "Infura (Default)";
+    return { provider: provider2, providerName: providerName2 };
+  }, [chainId]);
+  return { provider, providerName };
+};
+
+// src/contexts/Ethers/MetaMask.tsx
+import { useMemo as useMemo13 } from "react";
+
+// src/wallets/classes/EIP1193Events.ts
+import { forget } from "@ariestools/sdk";
+var EIP1193Events = class {
+  // list of EIP-1193 specific event names and listeners for easy cleanup
+  eip1193Listeners = [];
+  // opt-in to EIP-1193 events since not all wallets will support them
+  eventsEnabled = false;
+  listeningProvider;
+  // helpful for crafting debug/error messages to know the injected wallet
+  #providerName;
+  constructor(supportedEvents, provider, providerName) {
+    this.#providerName = providerName;
+    this.eventsEnabled = supportedEvents?.includes("EIP-1193") === true;
+    if (globalThis.ethereum === void 0 && provider === void 0) {
+      const providerLabel = this.#providerName ?? "unknown provider";
+      console.warn(`attempting to subscribe to EIP1193 events for ${providerLabel} but missing provider in arguments or at window.ethereum`);
+    }
+    this.listeningProvider = provider ?? globalThis.ethereum;
+  }
+  onAccountsChanged(listener) {
+    this.addListener("accountsChanged", listener);
+  }
+  onChainChanged(listener) {
+    this.addListener("chainChanged", listener);
+  }
+  onConnect(listener) {
+    this.addListener("connect", listener);
+  }
+  onDisconnect(listener) {
+    this.addListener("disconnect", listener);
+  }
+  removeEIP11193Listener(event, listener) {
+    this.enabled(() => {
+      forget(this.listeningProvider?.removeListener(event, listener) ?? Promise.resolve());
+      this.eip1193Listeners = this.eip1193Listeners.filter(([, savedListener]) => listener !== savedListener);
+    });
+  }
+  removeEIP11193Listeners() {
+    for (const [event, listener] of this.eip1193Listeners) {
+      forget(this.listeningProvider?.removeListener(event, listener) ?? Promise.resolve());
+    }
+  }
+  addListener(event, listener) {
+    this.enabled(() => {
+      forget(this.listeningProvider?.on(event, listener) ?? Promise.resolve());
+      this.eip1193Listeners.push([event, listener]);
+    });
+  }
+  enabled(method) {
+    if (this.eventsEnabled) {
+      method?.();
+    }
+  }
+};
+
+// src/wallets/classes/EIP6963Connector.ts
+import { forget as forget2 } from "@ariestools/sdk";
+
+// src/wallets/classes/EthWalletConnectorBase.ts
+import {
+  isDefined,
+  isString,
+  toAddress
+} from "@ariestools/sdk";
+import { verifyTypedData } from "ethers/hash";
+import { LRUCache } from "lru-cache";
+
+// src/wallets/types/events/AccountsChanged.ts
+var AccountsChangedEventName = "xyo:accounts:changed";
+
+// src/wallets/types/events/ChainChanged.ts
+var ChainChangedEventName = "xyo:chain:changed";
+
+// src/wallets/utils/findChain.ts
+import {
+  arbitrum,
+  base,
+  mainnet,
+  optimism,
+  polygon,
+  sepolia
+} from "viem/chains";
+var chains = [mainnet, polygon, arbitrum, optimism, base, sepolia];
+var findChainName = (chainId) => chains.find((chain) => chain.id === chainId);
+
+// src/wallets/classes/EthWalletConnectorBase.ts
+var EthWalletConnectorBase = class extends EIP1193Events {
+  // allowed accounts according to the wallet
+  allowedAccounts = [];
+  // instance of Ethers BrowserProvider
+  provider;
+  providerErrorLog = new LRUCache({ max: 300 });
+  // Assets provided by the wallet
+  providerInfo;
+  // instance of the raw provider injected by the wallet
+  rawProvider;
+  // Listeners that only want to be notified when accounts change
+  accountChangeNotifiers = [];
+  // Listeners that only want to be notified when chainId changes
+  chainChangedNotifiers = [];
+  // current chainId in hex format
+  chainIdHex = void 0;
+  constructor(supportedEvents, rawProvider, providerName) {
+    super(supportedEvents, rawProvider, providerName);
+  }
+  get chainId() {
+    return isString(this.chainIdHex) ? Number(this.chainIdHex) : void 0;
+  }
+  get chainName() {
+    if (!isDefined(this.chainId)) return;
+    const knownChain = findChainName(this.chainId);
+    return isDefined(knownChain) ? knownChain.name : this.chainId.toString();
+  }
+  /**
+   * Request to enable accounts in the wallet
+   * This call is not wrapped in a try/catch by design.  Errors from connecting to a wallet can be intentional behavior
+   * (i.e. the user rejected the request to connect).  Handle errors in the calling code.
+   */
+  async connectWallet() {
+    if (!this.provider) {
+      this.logProviderMissing();
+      return;
+    }
+    return await this.provider.send("eth_requestAccounts", []);
+  }
+  /**
+   * Request the current active allowed from the wallet
+   */
+  async currentAccounts() {
+    return await this.tryRpcSendCall("eth_accounts");
+  }
+  /**
+   * Request the current chain id selection on the wallet
+   */
+  async currentChainId() {
+    return await this.tryRpcSendCall("net_version");
+  }
+  /**
+   * Sign a string with a specific account enabled in the wallet
+   *
+   * @param message Message to sign with the signer
+   * @param allowedAccount Account being used to sign the message
+   */
+  async signMessage(message, allowedAccount) {
+    if (!this.provider) {
+      this.logProviderMissing();
+      return;
+    }
+    const signer = await this.signerFromAddress(allowedAccount);
+    const signature = await signer?.signMessage(message);
+    return signature;
+  }
+  /**
+   * Sign a typed message with a specific account enabled in the wallet according to EIP-712
+   * @param domain eip712Domain
+   * @param types A specific field of a structured eip-712 type.
+   * @param value The contents of the message to sign
+   * @param allowedAccount Account being used to sign the message
+   * @returns
+   *
+   * see - https://eips.ethereum.org/EIPS/eip-712
+   */
+  async signTypedMessage(domain, types2, value, allowedAccount) {
+    if (!this.provider) {
+      this.logProviderMissing();
+      return;
+    }
+    const signer = await this.signerFromAddress(allowedAccount);
+    const signature = await signer?.signTypedData(domain, types2, value);
+    return signature;
+  }
+  /**
+   * Get a signer from a given address
+   *
+   * @param address Fetch a signer for a given address
+   */
+  async signerFromAddress(address) {
+    return await this.provider?.getSigner(address);
+  }
+  /**
+   * Pass a callback to be notified when accounts are changed
+   * This is a notifier so it does not return updated values so check the allowed accounts
+   * after the passed listener is invoked
+   *
+   * @param listener A notify function that will be called when allowed accounts change
+   */
+  subscribeToAccountsChanges(listener) {
+    this.accountChangeNotifiers = [listener, ...this.accountChangeNotifiers];
+    return () => {
+      this.accountChangeNotifiers = this.accountChangeNotifiers.filter((l) => l !== listener);
+    };
+  }
+  /**
+   * Pass a callback to be notified when chainId is changed
+   * This is a notifier so it does not return updated values so check the chainId
+   * after the passed listener is invoked
+   *
+   * @param listener A notify function that will be called when chainId changes
+   */
+  subscribeToChainChanges(listener) {
+    this.chainChangedNotifiers = [listener, ...this.chainChangedNotifiers];
+    return () => {
+      this.chainChangedNotifiers = this.chainChangedNotifiers.filter((l) => l !== listener);
+    };
+  }
+  /**
+   * Verify a typed data signature according to EIP-712
+   * @param domain eip712Domain
+   * @param types A specific field of a structured eip-712 type.
+   * @param value The contents of the message to sign
+   * @param signature Signature produced by signTypedMessage
+   * @param expectedSignerAddress Expected signer address to verify against
+   * @returns boolean indicating if the signature is valid
+   */
+  verifyTypedDataSignature(domain, types2, value, signature, expectedSignerAddress) {
+    if (!this.provider) {
+      this.logProviderMissing();
+      return false;
+    }
+    const recoveredAddress = verifyTypedData(domain, types2, value, signature);
+    return toAddress(recoveredAddress.toLowerCase()) === toAddress(expectedSignerAddress.toLowerCase());
+  }
+  /**
+   * Keep class state internally consistent
+   */
+  async onAccountsChangedListener() {
+    this.allowedAccounts = await this.currentAccounts() ?? [];
+    this.notifySubscribers(this.accountChangeNotifiers, AccountsChangedEventName, { allowedAccounts: this.allowedAccounts });
+    const listener = (accounts) => {
+      this.allowedAccounts = accounts;
+      this.notifySubscribers(this.accountChangeNotifiers, AccountsChangedEventName, { allowedAccounts: this.allowedAccounts });
+    };
+    this.onAccountsChanged(listener);
+  }
+  /**
+   * Keep class state internally consistent
+   */
+  async onChainChangedListener() {
+    this.chainIdHex = await this.currentChainId() ?? void 0;
+    this.notifySubscribers(this.chainChangedNotifiers, ChainChangedEventName, { chainId: this.chainId });
+    const listener = (chainId) => {
+      this.chainIdHex = chainId;
+      this.notifySubscribers(this.chainChangedNotifiers, ChainChangedEventName, { chainId: this.chainId });
+    };
+    this.onChainChanged(listener);
+  }
+  logProviderErrors(error) {
+    const timestamp = Date.now();
+    this.providerErrorLog.set(`${this.providerName} - ${timestamp}`, error);
+  }
+  logProviderMissing() {
+    console.warn("Cannot call this method because there is no browser provider connected.  Please confirm that metamask is installed");
+  }
+  notifySubscribers(listeners, eventName, value) {
+    for (const listener of listeners) listener();
+    const details = { detail: { ...value, providerName: this.providerName } };
+    dispatchEvent(new CustomEvent(eventName, details));
+  }
+  async tryRpcSendCall(method, params = []) {
+    try {
+      return await this.provider?.send(method, params);
+    } catch (e) {
+      console.warn(`Error calling ${method} from ${this.providerName}`, e);
+      this.logProviderErrors(e);
+    }
+  }
+};
+
+// src/wallets/classes/EIP6963Connector.ts
+var EIP6963Connector = class extends EthWalletConnectorBase {
+  // Name of the Provider
+  providerName = "";
+  constructor(provider, rawProvider, info) {
+    super(["EIP-1193"], rawProvider, info?.name);
+    this.provider = provider;
+    this.rawProvider = rawProvider;
+    this.providerInfo = info;
+    this.providerName = info?.name ?? "";
+    this.init();
+  }
+  get installed() {
+    return !!this.provider;
+  }
+  init() {
+    if (!this.installed) {
+      return;
+    }
+    forget2(this.onAccountsChangedListener());
+    forget2(this.onChainChangedListener());
+  }
+};
+
+// src/wallets/classes/EthWalletApiInstance.ts
+import { assertEx } from "@ariestools/sdk";
+var EthWalletApiInstance = class {
+  _ethWalletConnector;
+  constructor(ethWalletConnector) {
+    this._ethWalletConnector = ethWalletConnector;
+  }
+  get eip1193Provider() {
+    return assertEx("request" in (this.ethWalletConnector.rawProvider ?? {}) ? this.ethWalletConnector.rawProvider : null, () => "Provider does not support request method");
+  }
+  get ethWalletConnector() {
+    return this._ethWalletConnector;
+  }
+  async switchEthereumChain(chainId) {
+    assertEx(this.ethWalletConnector.chainId, () => "No chainId connected");
+    assertEx(chainId, () => "No chainId provided");
+    if (this.ethWalletConnector.chainId !== Number(chainId)) {
+      await this.eip1193Provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId }]
+      });
+    }
+  }
+};
+
+// src/wallets/classes/EthWalletConnections.ts
+import { isString as isString2 } from "@ariestools/sdk";
+import { BrowserProvider } from "ethers/providers";
+
+// src/wallets/eip/6963/Eip6963.ts
+import { isDefined as isDefined2 } from "@ariestools/sdk";
+var isEIP6963AnnounceProviderEvent = (event) => {
+  const castEvent = event;
+  return isDefined2(castEvent.detail) && isDefined2(castEvent.detail.info) && isDefined2(castEvent.detail.provider);
+};
+
+// src/wallets/classes/EthWalletConnections.ts
+var EthWalletConnections = class {
+  announceProviderListener = this.newWalletListener.bind(this);
+  discoveredWallets = {};
+  listeners = [];
+  constructor() {
+    this.setupListeners();
+  }
+  addWallet(wallet) {
+    const walletName = wallet.providerInfo?.rdns;
+    if (isString2(walletName) && !Object.hasOwn(this.discoveredWallets, walletName)) {
+      this.discoveredWallets = {
+        [walletName]: wallet,
+        ...this.discoveredWallets
+      };
+      this.emitChange();
+    }
+  }
+  onDestroy() {
+    removeEventListener("eip6963:announceProvider", this.announceProviderListener);
+  }
+  removeWallet(wallet) {
+    const walletName = wallet.providerInfo?.rdns;
+    if (isString2(walletName) && Object.hasOwn(this.discoveredWallets, walletName)) {
+      delete this.discoveredWallets[walletName];
+      this.discoveredWallets = { ...this.discoveredWallets };
+      this.emitChange();
+    }
+  }
+  subscribe(listener) {
+    this.listeners = [...this.listeners, listener];
+    return () => {
+      this.listeners = this.listeners.filter((existingListener) => existingListener !== listener);
+    };
+  }
+  wallets() {
+    return this.discoveredWallets;
+  }
+  emitChange() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  newWalletListener(event) {
+    if (!isEIP6963AnnounceProviderEvent(event)) return;
+    const { info, provider } = event.detail;
+    this.addWallet(new EIP6963Connector(new BrowserProvider(provider), provider, info));
+  }
+  setupListeners() {
+    addEventListener("eip6963:announceProvider", this.announceProviderListener);
+    dispatchEvent(new Event("eip6963:requestProvider"));
+  }
+};
+
+// src/wallets/components/Discovery/hooks/use.tsx
+import { useSyncExternalStore } from "react";
+var ethWalletConnections;
+var getEthWalletConnections = () => {
+  ethWalletConnections ??= new EthWalletConnections();
+  return ethWalletConnections;
+};
+var useWalletDiscovery = () => {
+  const connections = getEthWalletConnections();
+  return useSyncExternalStore(connections.subscribe.bind(connections), connections.wallets.bind(connections));
+};
+
+// src/wallets/components/Discovery/MenuItem.tsx
+import { RadioButtonChecked } from "@mui/icons-material";
+import {
+  ListItemIcon,
+  ListItemText,
+  MenuItem,
+  styled,
+  useTheme
+} from "@mui/material";
+
+// src/wallets/hooks/useChainId.tsx
+import { isDefined as isDefined3 } from "@ariestools/sdk";
+import { useMemo as useMemo3, useSyncExternalStore as useSyncExternalStore2 } from "react";
+var useChainId = (ethWalletConnector) => {
+  const { getSnapShot, subscribe } = useMemo3(() => {
+    if (ethWalletConnector?.installed === true) {
+      return {
+        getSnapShot: () => isDefined3(ethWalletConnector) ? ethWalletConnector.chainId : void 0,
+        subscribe: (onStoreChange) => ethWalletConnector?.subscribeToChainChanges(onStoreChange)
+      };
+    }
+    return {
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      getSnapShot: () => void 0,
+      // eslint-disable-next-line unicorn/no-useless-undefined
+      subscribe: () => () => void 0
+    };
+  }, [ethWalletConnector]);
+  return useSyncExternalStore2(subscribe, getSnapShot);
+};
+
+// src/wallets/hooks/useConnect.tsx
+import { isError } from "ethers/utils";
+import { useCallback, useState } from "react";
+var checkAccounts = (accounts) => {
+  if (accounts && accounts?.length !== 0) {
+    console.log("Connected:", accounts[0]);
+    return accounts;
+  }
+  console.log("No authorized account found.");
+};
+var handleActionRejected = (e, rejectCallback) => {
+  if (!isError(e, "ACTION_REJECTED")) return;
+  const error = e.info?.error;
+  if (error?.code !== 4001) return;
+  rejectCallback(error);
+};
+var useConnectWallet = (ethWalletConnector) => {
+  const [connectRefused, setConnectRefused] = useState(false);
+  const [connectError, setConnectError] = useState();
+  const connectWallet = useCallback(async () => {
+    if (!ethWalletConnector) return;
+    try {
+      const accounts = await ethWalletConnector?.connectWallet();
+      setConnectRefused(false);
+      setConnectError(void 0);
+      return checkAccounts(accounts);
+    } catch (e) {
+      handleActionRejected(e, (error) => {
+        setConnectRefused(true);
+        setConnectError(new Error(error.message));
+      });
+    }
+  }, [ethWalletConnector]);
+  return ethWalletConnector?.installed === true ? {
+    connectError,
+    connectRefused,
+    connectWallet
+  } : {};
+};
+
+// src/wallets/hooks/useCurrentAccount.ts
+import { EthAddressWrapper } from "@xylabs/eth-address";
+import { useMemo as useMemo5 } from "react";
+
+// src/wallets/hooks/useCurrentAccountExternal.ts
+import { isDefined as isDefined4 } from "@ariestools/sdk";
+import { useMemo as useMemo4, useSyncExternalStore as useSyncExternalStore3 } from "react";
+var EMPTY_ARRAY = [];
+var useCurrentAccountExternal = (ethWalletConnector) => {
+  const { getSnapShot, subscribe } = useMemo4(() => {
+    return {
+      getSnapShot: () => isDefined4(ethWalletConnector) ? ethWalletConnector.allowedAccounts : EMPTY_ARRAY,
+      subscribe: (notifier) => isDefined4(ethWalletConnector) ? ethWalletConnector.subscribeToAccountsChanges(notifier) : () => void 0
+    };
+  }, [ethWalletConnector]);
+  return useSyncExternalStore3(subscribe, getSnapShot);
+};
+
+// src/wallets/hooks/useCurrentAccount.ts
+var useCurrentAccount = (ethWalletConnector) => {
+  const addresses = useCurrentAccountExternal(ethWalletConnector);
+  const [currentAddress, additionalAddresses] = useMemo5(() => {
+    return addresses?.length > 0 ? [EthAddressWrapper.fromString(addresses[0]), addresses.slice(1)] : [void 0, []];
+  }, [addresses]);
+  if (ethWalletConnector?.installed !== true) return [void 0, []];
+  return [currentAddress, additionalAddresses];
+};
+
+// src/wallets/hooks/useEip6963Wallet.ts
+import { useMemo as useMemo8 } from "react";
+
+// src/wallets/hooks/useEthWallet.tsx
+import { isDefined as isDefined6 } from "@ariestools/sdk";
+import { usePromise as usePromise2 } from "../../promise/browser/index.mjs";
+import { EthAddressWrapper as EthAddressWrapper2 } from "@xylabs/eth-address";
+import { useMemo as useMemo7 } from "react";
+
+// src/wallets/hooks/useProvider.tsx
+import { isDefined as isDefined5 } from "@ariestools/sdk";
+import { useMemo as useMemo6 } from "react";
+var useProvider = (ethWalletConnector) => {
+  return useMemo6(() => {
+    if (isDefined5(ethWalletConnector) && ethWalletConnector.installed) {
+      return {
+        provider: ethWalletConnector.provider,
+        providerName: ethWalletConnector.providerName,
+        rawProvider: ethWalletConnector.rawProvider
+      };
+    }
+    return {
+      provider: void 0,
+      providerName: void 0,
+      rawProvider: void 0
+    };
+  }, [ethWalletConnector]);
+};
+
+// src/wallets/hooks/useSigner.tsx
+import { usePromise } from "../../promise/browser/index.mjs";
+var useSigner = (ethWalletConnector, localAddress) => {
+  const [signer] = usePromise(async () => {
+    if (ethWalletConnector?.installed === true) {
+      try {
+        if (localAddress) {
+          return await ethWalletConnector.signerFromAddress(localAddress?.toString());
+        }
+      } catch (ex) {
+        console.error(ex);
+      }
+    }
+  }, [localAddress, ethWalletConnector]);
+  return signer;
+};
+
+// src/wallets/hooks/useEthWallet.tsx
+var useEthWallet = (connector) => {
+  const [currentAccount, additionalAccounts] = useCurrentAccount(connector);
+  const chainId = useChainId(connector);
+  const chainName = useMemo7(() => isDefined6(chainId) && isDefined6(connector?.chainName) ? connector.chainName : void 0, [chainId, connector]);
+  const {
+    provider,
+    providerName,
+    rawProvider
+  } = useProvider(connector) ?? {};
+  const {
+    connectWallet,
+    connectRefused,
+    connectError
+  } = useConnectWallet(connector);
+  const signer = useSigner(connector, currentAccount);
+  const [signerAddress] = usePromise2(async () => EthAddressWrapper2.fromString(await signer?.getAddress()), [signer]);
+  const signMessage = useMemo7(() => connector?.signMessage.bind(connector), [connector]);
+  const signTypedMessage = useMemo7(() => connector?.signTypedMessage.bind(connector), [connector]);
+  const verifyTypedDataSignature = useMemo7(() => connector?.verifyTypedDataSignature?.bind(connector), [connector]);
+  const installed = useMemo7(() => connector?.installed, [connector?.installed]);
+  const providerInfo = useMemo7(() => connector?.providerInfo, [connector?.providerInfo]);
+  return {
+    additionalAccounts,
+    chainId,
+    chainName,
+    connectError,
+    connectRefused,
+    connectWallet,
+    currentAccount,
+    installed,
+    provider,
+    providerInfo,
+    rawProvider,
+    providerName,
+    signMessage,
+    signTypedMessage,
+    signer,
+    signerAddress,
+    verifyTypedDataSignature
+  };
+};
+
+// src/wallets/hooks/useEip6963Wallet.ts
+var useEip6963Wallet = (selectedWallet) => {
+  const {
+    info,
+    provider,
+    rawProvider
+  } = selectedWallet ?? {};
+  const connector = useMemo8(() => new EIP6963Connector(provider, rawProvider, info), [info, provider, rawProvider]);
+  return useEthWallet(connector);
+};
+
+// src/wallets/hooks/useEthWalletApiInstance.ts
+import { useMemo as useMemo10 } from "react";
+
+// src/hooks/useNavigateToEthAddress.ts
+import { isDefined as isDefined7, isString as isString3 } from "@ariestools/sdk";
+import { createPath, useNavigate } from "react-router-dom";
+var toPath = (to) => {
+  if (typeof to === "string") {
+    return to;
+  }
+  return createPath({
+    ...to,
+    pathname: to.pathname ?? ""
+  });
+};
+var useNavigateToEthAddress = () => {
+  const navigate = useNavigate();
+  const navigateToEthAddress = (address, event, page, to, toOptions, toEtherScan) => {
+    const openInEtherScan = toEtherScan ?? (!isDefined7(to) && !isString3(page));
+    if (openInEtherScan) {
+      window.open(`https://etherscan.io/address/${address.toString()}`, "_blank");
+    } else {
+      const path = isDefined7(to) ? toPath(to) : `/${page}/${address.toString()}`;
+      if (event.metaKey === true || toEtherScan === true) {
+        window.open(path, "_blank");
+      } else {
+        void navigate(to ?? path, toOptions);
+      }
+    }
+  };
+  return { navigateToEthAddress };
+};
+
+// src/hooks/useTryMethodCalls.ts
+import { useMemo as useMemo9, useState as useState2 } from "react";
+var useTryMethodCalls = (instance) => {
+  const [error, setError] = useState2();
+  const proxy = useMemo9(() => new Proxy(instance, {
+    get(target, prop, receiver) {
+      const orig = Reflect.get(target, prop, receiver);
+      if (typeof orig === "function" && typeof prop === "string" && !prop.startsWith("_")) {
+        setError(void 0);
+        return async function(...args) {
+          try {
+            return await Reflect.apply(orig, instance, args);
+          } catch (err) {
+            setError(err);
+            throw err;
+          }
+        };
+      }
+      return orig;
+    }
+  }), [instance]);
+  return { instance: proxy, error };
+};
+
+// src/wallets/hooks/useEthWalletApiInstance.ts
+var useEthWalletApiInstance = (connector) => {
+  const apiInstance = useMemo10(() => new EthWalletApiInstance(connector), [connector]);
+  const { instance, error } = useTryMethodCalls(apiInstance);
+  return {
+    ethWalletApiInstance: instance,
+    error
+  };
+};
+
+// src/wallets/hooks/useEthWalletInstance.ts
+var useEthWalletInstance = (connector) => {
+  const ethWalletApiInstance = useEthWalletApiInstance(connector);
+  const ethWallet = useEthWallet(connector);
+  return {
+    ...ethWalletApiInstance,
+    ...ethWallet
+  };
+};
+
+// src/wallets/components/shared/ConstrainedImage.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ConstrainedImage = ({ constrainedValue = "42px", ...props }) => {
+  return /* @__PURE__ */ jsx2("span", { style: { height: constrainedValue, width: constrainedValue }, children: /* @__PURE__ */ jsx2("img", { style: { maxWidth: constrainedValue }, ...props }) });
+};
+
+// src/wallets/components/Discovery/MenuItem.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var WalletDiscoveryMenuItemInner = ({
+  approvedAccount,
+  icon,
+  name,
+  ...props
+}) => {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs(StyledMenuItem, { ...props, children: [
+    /* @__PURE__ */ jsx3(ListItemIcon, { children: /* @__PURE__ */ jsx3(ConstrainedImage, { constrainedValue: theme.spacing(3), src: icon }) }),
+    /* @__PURE__ */ jsx3(ListItemText, { children: name }),
+    approvedAccount === true ? /* @__PURE__ */ jsx3(StyledActiveIcon, { children: /* @__PURE__ */ jsx3(RadioButtonChecked, { color: "success" }) }) : null
+  ] });
+};
+var StyledMenuItem = styled(MenuItem, { name: "StyledMenuItem" })(({ theme }) => ({
+  "&:not(:last-child)": { borderBottom: `1px solid ${theme.vars.palette.divider}` },
+  "padding": theme.spacing(2)
+}));
+var StyledActiveIcon = styled(ListItemIcon, { name: "StyledActiveIcon" })(({ theme }) => ({
+  flexGrow: 1,
+  justifyContent: "end",
+  paddingLeft: theme.spacing(2)
+}));
+var WalletDiscoveryMenuItem = ({ ethWalletConnector, ...props }) => {
+  const { currentAccount, providerInfo } = useEthWallet(ethWalletConnector);
+  return /* @__PURE__ */ jsx3(WalletDiscoveryMenuItemInner, { approvedAccount: !!currentAccount, icon: providerInfo?.icon, name: providerInfo?.name, ...props });
+};
+
+// src/wallets/components/Discovery/MenuItems.tsx
+import { exists } from "@ariestools/sdk";
+import { Alert } from "@mui/material";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WalletsDiscoveredMenuItems = ({
+  discoveredWallets,
+  onWalletSelect,
+  suppressNoWalletsWarning,
+  ...props
+}) => {
+  return discoveredWallets ? Object.values(discoveredWallets).filter(exists).map((eip6963Connector) => /* @__PURE__ */ jsx4(
+    WalletDiscoveryMenuItem,
+    {
+      ethWalletConnector: eip6963Connector,
+      onClick: () => onWalletSelect?.(eip6963Connector),
+      ...props
+    },
+    eip6963Connector.providerName
+  )) : suppressNoWalletsWarning === true ? null : /* @__PURE__ */ jsx4(Alert, { severity: "warning", children: "Unable to locate any installed wallets" });
+};
+
+// src/wallets/components/Discovery/Paper.tsx
+import { Paper } from "@mui/material";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var WalletDiscoveryPaper = ({ onWalletSelect, ...props }) => {
+  const discoveredWallets = useWalletDiscovery();
+  return /* @__PURE__ */ jsx5(Paper, { elevation: 2, ...props, children: /* @__PURE__ */ jsx5(WalletsDiscoveredMenuItems, { discoveredWallets, onWalletSelect }) });
+};
+
+// src/wallets/components/Overview/Card.tsx
+import { ErrorRender } from "../../error/browser/index.mjs";
+import { Card } from "@mui/material";
+import { useMemo as useMemo12, useState as useState4 } from "react";
+
+// src/wallets/components/Overview/CardActions.tsx
+import { FlexCol } from "../../flexbox/browser/index.mjs";
+import { Button, CardActions } from "@mui/material";
+import { useState as useState3 } from "react";
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var WalletOverviewCardActions = ({
+  connectWallet,
+  currentAccount,
+  onSign,
+  onSignTypedData,
+  onSwitchChain,
+  sx,
+  ...props
+}) => {
+  const [connecting, setConnecting] = useState3(false);
+  const onConnect = () => void (async () => {
+    setConnecting(true);
+    try {
+      await connectWallet?.();
+    } catch (e) {
+      console.warn(e);
+    }
+    setConnecting(false);
+  })();
+  return /* @__PURE__ */ jsx6(
+    CardActions,
+    {
+      ...props,
+      children: /* @__PURE__ */ jsxs2(
+        FlexCol,
+        {
+          sx: {
+            gap: 2,
+            width: "100%"
+          },
+          children: [
+            /* @__PURE__ */ jsx6(Button, { fullWidth: true, disabled: !currentAccount, variant: "contained", onClick: () => onSign ? void onSign() : void 0, size: "small", children: "Sign Test Message" }),
+            /* @__PURE__ */ jsx6(
+              Button,
+              {
+                fullWidth: true,
+                disabled: !currentAccount,
+                variant: "contained",
+                onClick: () => onSignTypedData ? void onSignTypedData() : void 0,
+                size: "small",
+                children: "Sign Typed Data Message"
+              }
+            ),
+            /* @__PURE__ */ jsx6(Button, { fullWidth: true, size: "small", disabled: connecting || !!currentAccount, variant: "contained", onClick: onConnect, children: currentAccount ? "Connected" : "Connect" }),
+            /* @__PURE__ */ jsx6(Button, { fullWidth: true, size: "small", variant: "contained", onClick: () => void onSwitchChain?.(), children: "Switch Chain" })
+          ]
+        }
+      )
+    }
+  );
+};
+
+// src/wallets/components/Overview/CardContent.tsx
+import { isDefined as isDefined8 } from "@ariestools/sdk";
+import { FlexCol as FlexCol2, FlexRow } from "../../flexbox/browser/index.mjs";
+import { Cancel, Check } from "@mui/icons-material";
+import {
+  Alert as Alert2,
+  AlertTitle,
+  CardContent,
+  Chip,
+  Divider,
+  styled as styled2,
+  Typography
+} from "@mui/material";
+import { useMemo as useMemo11 } from "react";
+import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var WalletOverviewCardContent = ({
+  chainName,
+  connectError,
+  connectRefused,
+  currentAccount,
+  signResponse,
+  domain,
+  types: types2,
+  values: values2,
+  validateTypedDataSignature,
+  verifyTypedDataSignature,
+  sx,
+  ...props
+}) => {
+  const validSignature = useMemo11(() => {
+    if (isDefined8(signResponse) && isDefined8(types2) && isDefined8(values2) && isDefined8(currentAccount) && validateTypedDataSignature === true) {
+      return verifyTypedDataSignature?.(domain, types2, values2, signResponse, currentAccount.toString());
+    }
+  }, [signResponse, validateTypedDataSignature, domain, types2, values2, currentAccount, verifyTypedDataSignature]);
+  return /* @__PURE__ */ jsxs3(
+    CardContent,
+    {
+      sx: {
+        display: "flex",
+        flexDirection: "column",
+        gap: 2,
+        ...sx
+      },
+      ...props,
+      children: [
+        window.parent === globalThis ? null : /* @__PURE__ */ jsx7(Alert2, { severity: "warning", children: /* @__PURE__ */ jsx7(AlertTitle, { children: "Avoid calling wallets inside of iFrames" }) }),
+        /* @__PURE__ */ jsxs3(
+          FlexRow,
+          {
+            sx: {
+              justifyContent: "space-between",
+              alignItems: "start",
+              gap: 2
+            },
+            children: [
+              /* @__PURE__ */ jsxs3(
+                FlexCol2,
+                {
+                  sx: {
+                    alignItems: "start",
+                    justifyContent: "start"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx7(StyledTypographyHeading, { variant: "overline", children: "Approved Address:" }),
+                    /* @__PURE__ */ jsx7(Chip, { label: currentAccount ? currentAccount?.toShortString() : "none" })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs3(
+                FlexCol2,
+                {
+                  sx: {
+                    alignItems: "start",
+                    justifyContent: "start"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx7(StyledTypographyHeading, { variant: "overline", children: "Chain:" }),
+                    /* @__PURE__ */ jsx7(Chip, { label: chainName ?? "unknown" })
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx7(Divider, { flexItem: true }),
+        connectRefused === true ? /* @__PURE__ */ jsxs3(Alert2, { severity: "error", children: [
+          /* @__PURE__ */ jsx7(AlertTitle, { children: "Connection Refused" }),
+          "Error:",
+          " ",
+          connectError?.message
+        ] }) : null,
+        isDefined8(signResponse) ? /* @__PURE__ */ jsxs3(Alert2, { severity: "success", children: [
+          /* @__PURE__ */ jsx7(AlertTitle, { children: "Sign Response" }),
+          signResponse,
+          validateTypedDataSignature === true ? validSignature === true ? /* @__PURE__ */ jsxs3("span", { children: [
+            /* @__PURE__ */ jsx7(Check, {}),
+            " ",
+            "Verified Signature"
+          ] }) : /* @__PURE__ */ jsxs3("span", { children: [
+            /* @__PURE__ */ jsx7(Cancel, { color: "error" }),
+            " ",
+            "Could not verify signature"
+          ] }) : null
+        ] }) : null
+      ]
+    }
+  );
+};
+var StyledTypographyHeading = styled2(Typography, { name: "StyledTypographyHeading" })(() => ({ opacity: 0.7 }));
+
+// src/wallets/components/Overview/CardHeader.tsx
+import { CheckCircleOutlined } from "@mui/icons-material";
+import { CardHeader } from "@mui/material";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var WalletOverviewCardHeader = ({
+  currentAccount,
+  icon,
+  walletName,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx8(
+    CardHeader,
+    {
+      avatar: /* @__PURE__ */ jsx8(ConstrainedImage, { constrainedValue: "42px", src: icon }),
+      title: walletName,
+      action: currentAccount ? /* @__PURE__ */ jsx8(CheckCircleOutlined, { color: "success" }) : null,
+      ...props
+    }
+  );
+};
+
+// src/wallets/components/Overview/lib/SampleTypedData.ts
+var buildDomain = (chainId) => ({
+  name: "MyApp",
+  version: "1",
+  chainId: chainId ?? 1,
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+});
+var types = { Payload: [{ name: "hash", type: "string" }, { name: "schema", type: "string" }] };
+var values = {
+  hash: "0x1a2b3c4d5e6f7890abcdef1234567890abcdef1234567890abcdef1234567890",
+  schema: "network.xyo.hash"
+};
+
+// src/wallets/components/Overview/Card.tsx
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+var WalletOverviewCard = ({ ethWalletConnector, ...props }) => {
+  const {
+    chainId,
+    connectWallet,
+    connectRefused,
+    chainName,
+    connectError,
+    currentAccount,
+    providerInfo,
+    providerName,
+    ethWalletApiInstance,
+    signMessage,
+    signTypedMessage,
+    signerAddress,
+    verifyTypedDataSignature
+  } = useEthWalletInstance(ethWalletConnector);
+  const domain = useMemo12(() => buildDomain(chainId), [chainId]);
+  const [signResponse, setSignResponse] = useState4();
+  const [error, setError] = useState4();
+  const [validateTypedDataSignature, setValidateTypedDataSignature] = useState4(false);
+  const [previousSignerAddress, setPreviousSignerAddress] = useState4();
+  if (signerAddress !== previousSignerAddress) {
+    setPreviousSignerAddress(signerAddress);
+    setSignResponse(void 0);
+  }
+  const onSign = async () => {
+    setSignResponse(void 0);
+    setValidateTypedDataSignature(false);
+    const signResult = await signMessage?.("test");
+    setSignResponse(signResult);
+  };
+  const onSignTypedData = async () => {
+    try {
+      setError(void 0);
+      setSignResponse(void 0);
+      const signature = await signTypedMessage?.(domain, types, values);
+      setSignResponse(signature);
+      setValidateTypedDataSignature(true);
+    } catch (err) {
+      setValidateTypedDataSignature(false);
+      setError(err);
+    }
+  };
+  const onSwitchChain = async () => {
+    const mainnet2 = "0x1";
+    const sepolia2 = "0xaa36a7";
+    await (chainId === 1 ? ethWalletApiInstance.switchEthereumChain(sepolia2) : ethWalletApiInstance.switchEthereumChain(mainnet2));
+  };
+  return /* @__PURE__ */ jsxs4(Card, { ...props, children: [
+    /* @__PURE__ */ jsx9(ErrorRender, { error }),
+    /* @__PURE__ */ jsx9(WalletOverviewCardHeader, { currentAccount, icon: providerInfo?.icon, walletName: providerName }),
+    /* @__PURE__ */ jsx9(
+      WalletOverviewCardContent,
+      {
+        chainName,
+        connectError,
+        connectRefused,
+        currentAccount,
+        domain,
+        types,
+        values,
+        validateTypedDataSignature,
+        signResponse,
+        verifyTypedDataSignature
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      WalletOverviewCardActions,
+      {
+        connectWallet,
+        currentAccount,
+        onSign,
+        onSignTypedData,
+        onSwitchChain
+      }
+    )
+  ] });
+};
+
+// src/wallets/third-party/Coinbase/CoinbaseConnector.ts
+import { forget as forget3 } from "@ariestools/sdk";
+import { BrowserProvider as BrowserProvider2 } from "ethers/providers";
+var PROVIDER_NAME = "Coinbase";
+var CoinbaseConnector = class extends EthWalletConnectorBase {
+  // Name of the Provider
+  providerName = PROVIDER_NAME;
+  ethereum = globalThis.ethereum;
+  constructor(provider) {
+    super(["EIP-1193"], void 0, PROVIDER_NAME);
+    this.init(provider);
+  }
+  get installed() {
+    return this.ethereum?.isCoinbaseWallet === true;
+  }
+  init(provider) {
+    if (provider) {
+      this.provider = provider;
+    } else if (globalThis.ethereum) {
+      this.provider = new BrowserProvider2(globalThis.ethereum);
+    } else {
+      console.warn(`Attempting to use ${this.providerName} class when its not installed`);
+    }
+    if (this.installed) {
+      forget3(this.onAccountsChangedListener());
+      forget3(this.onChainChangedListener());
+    }
+  }
+};
+
+// src/wallets/third-party/Coinbase/use.ts
+var coinbaseConnector;
+var getCoinbaseConnector = () => {
+  coinbaseConnector ??= new CoinbaseConnector();
+  return coinbaseConnector;
+};
+var useCoinbaseWallet = () => {
+  return useEthWallet(getCoinbaseConnector());
+};
+
+// src/wallets/third-party/MetaMask/MetaMaskConnector.ts
+import { forget as forget4 } from "@ariestools/sdk";
+import { BrowserProvider as BrowserProvider3 } from "ethers/providers";
+var PROVIDER_NAME2 = "MetaMask";
+var MetaMaskConnector = class extends EthWalletConnectorBase {
+  // Name of the Provider
+  providerName = "MetaMask";
+  ethereum = globalThis.ethereum;
+  constructor(provider) {
+    super(["EIP-1193"], void 0, PROVIDER_NAME2);
+    this.init(provider);
+  }
+  get installed() {
+    return this.ethereum?.isMetaMask === true && globalThis.phantom?.ethereum?.isPhantom !== true;
+  }
+  init(provider) {
+    if (provider) {
+      this.provider = provider;
+    } else if (globalThis.ethereum) {
+      this.provider = new BrowserProvider3(globalThis.ethereum);
+    } else {
+      console.warn(`Attempting to use ${this.providerName} class when its not installed`);
+    }
+    if (this.installed) {
+      forget4(this.onAccountsChangedListener());
+      forget4(this.onChainChangedListener());
+    }
+  }
+};
+
+// src/wallets/third-party/MetaMask/use.tsx
+var metamaskConnector;
+var getMetaMaskConnector = () => {
+  metamaskConnector ??= new MetaMaskConnector();
+  return metamaskConnector;
+};
+var useMetaMask = () => {
+  return useEthWallet(getMetaMaskConnector());
+};
+
+// src/wallets/third-party/Phantom/PhantomConnector.ts
+import { forget as forget5 } from "@ariestools/sdk";
+import { BrowserProvider as BrowserProvider4 } from "ethers/providers";
+var PROVIDER_NAME3 = "Phantom";
+var PhantomConnector = class extends EthWalletConnectorBase {
+  // Name of the Provider
+  providerName = PROVIDER_NAME3;
+  ethereum = globalThis.phantom?.ethereum;
+  constructor(provider) {
+    super(["EIP-1193"], void 0, PROVIDER_NAME3);
+    this.init(provider);
+  }
+  get installed() {
+    return globalThis.phantom?.ethereum?.isPhantom === true;
+  }
+  init(provider) {
+    if (provider) {
+      this.provider = provider;
+    } else if (this.ethereum) {
+      this.provider = new BrowserProvider4(this.ethereum);
+    } else {
+      console.warn(`Attempting to use ${this.providerName} class when its not installed`);
+    }
+    if (this.installed) {
+      forget5(this.onAccountsChangedListener());
+      forget5(this.onChainChangedListener());
+    }
+  }
+};
+
+// src/wallets/third-party/Phantom/use.tsx
+var phantomConnector;
+var getPhantomConnector = () => {
+  phantomConnector ??= new PhantomConnector();
+  return phantomConnector;
+};
+var usePhantomWallet = () => {
+  return useEthWallet(getPhantomConnector());
+};
+
+// src/wallets/third-party/Trust/TrustConnector.ts
+import { forget as forget6 } from "@ariestools/sdk";
+import { BrowserProvider as BrowserProvider5 } from "ethers/providers";
+var TrustConnector = class extends EthWalletConnectorBase {
+  // Name of the Provider
+  providerName = "Trust";
+  // instance of provider with Trust specific methods
+  ethereum = globalThis.ethereum;
+  constructor(provider) {
+    super(["EIP-1193"]);
+    this.init(provider);
+  }
+  get installed() {
+    return this.ethereum?.isTrust === true;
+  }
+  init(provider) {
+    if (provider) {
+      this.provider = provider;
+    } else if (globalThis.ethereum) {
+      this.provider = new BrowserProvider5(globalThis.ethereum);
+    } else {
+      console.warn(`Attempting to use ${this.providerName} class when its not installed`);
+    }
+    if (this.installed) {
+      forget6(this.onAccountsChangedListener());
+      forget6(this.onChainChangedListener());
+    }
+  }
+};
+
+// src/wallets/third-party/Trust/use.ts
+var trustConnector;
+var getTrustConnector = () => {
+  trustConnector ??= new TrustConnector();
+  return trustConnector;
+};
+var useTrustWallet = () => {
+  return useEthWallet(getTrustConnector());
+};
+
+// src/contexts/Ethers/MetaMask.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var MetaMaskEthersLoader = ({
+  children,
+  defaultChainId,
+  enabled
+}) => {
+  void defaultChainId;
+  void enabled;
+  const {
+    chainId,
+    connectWallet: connect,
+    connectRefused,
+    connectError,
+    currentAccount: currentAddress,
+    installed,
+    provider,
+    providerName,
+    signMessage,
+    signer,
+    signerAddress
+  } = useMetaMask();
+  const value = useMemo13(() => ({
+    busy: false,
+    chainId,
+    connect,
+    connectRefused,
+    error: connectError,
+    isConnected: installed,
+    localAddress: currentAddress,
+    provider,
+    providerName,
+    signMessage,
+    signer,
+    signerAddress: signerAddress?.toString(),
+    walletProvider: provider
+  }), [
+    chainId,
+    connect,
+    connectRefused,
+    connectError,
+    installed,
+    currentAddress,
+    provider,
+    providerName,
+    signMessage,
+    signer,
+    signerAddress
+  ]);
+  return /* @__PURE__ */ jsx10(
+    EthersContext,
+    {
+      value,
+      children
+    }
+  );
+};
+
+// src/contexts/Ethers/MyEtherWallet.tsx
+import { useAsyncEffect } from "../../async-effect/browser/index.mjs";
+import { EthAddressWrapper as EthAddressWrapper3 } from "@xylabs/eth-address";
+import { BrowserProvider as BrowserProvider6, InfuraProvider as InfuraProvider3 } from "ethers/providers";
+import {
+  useCallback as useCallback2,
+  useEffect,
+  useMemo as useMemo14,
+  useState as useState5
+} from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var MyEtherWalletEthersLoader = (props) => {
+  const { children, enabled } = props;
+  const ethereum = globalThis.ethereum;
+  void enabled;
+  const [error, setError] = useState5();
+  const [localAddress, setLocalAddress] = useState5();
+  const [providerName, setProviderName] = useState5();
+  useEffect(() => {
+    if (ethereum) {
+      ethereum.autoRefreshOnNetworkChange = false;
+    }
+  }, [ethereum]);
+  const connect = useCallback2(async () => {
+    await ethereum?.enable?.();
+    return localAddress ? [localAddress.toString()] : [];
+  }, [ethereum, localAddress]);
+  const [isConnected, setIsConnected] = useState5();
+  const [walletProvider, setWalletProvider] = useState5();
+  const [provider, setProvider] = useState5();
+  const [signer, setSigner] = useState5();
+  useAsyncEffect(
+    async () => {
+      const walletProvider2 = ethereum ? new BrowserProvider6(ethereum) : void 0;
+      let provider2;
+      let providerName2;
+      if (walletProvider2) {
+        provider2 = walletProvider2;
+        providerName2 = "MyEtherWallet";
+      } else {
+        provider2 = new InfuraProvider3(1, infuraKey);
+        providerName2 = "Infura (Default)";
+      }
+      setProvider(provider2);
+      setProviderName(providerName2);
+      setWalletProvider(walletProvider2);
+      let signer2;
+      try {
+        const [existingAddress] = await provider2.send("eth_accounts", []) ?? [];
+        if (existingAddress) {
+          setLocalAddress(EthAddressWrapper3.fromString(existingAddress));
+        }
+        if (localAddress && walletProvider2) {
+          signer2 = await walletProvider2?.getSigner();
+        }
+      } catch (ex) {
+        console.error(ex);
+      }
+      setSigner(signer2);
+    },
+    [ethereum, isConnected, localAddress]
+  );
+  useAsyncEffect(
+    async (isMounted) => {
+      if (signer) {
+        try {
+          const localAddress2 = EthAddressWrapper3.fromString(await signer.getAddress());
+          if (isMounted()) {
+            setLocalAddress(localAddress2);
+            setIsConnected(true);
+          }
+        } catch (ex) {
+          if (isMounted()) {
+            setError(new Error(`localAddress: ${String(ex)}`));
+            setLocalAddress(void 0);
+            setIsConnected(false);
+          }
+        }
+      }
+    },
+    [signer]
+  );
+  const [chainId, setChainId] = useState5();
+  useAsyncEffect(
+    async (isMounted) => {
+      if (!isMounted()) return;
+      const network = await provider?.getNetwork();
+      const chainId2 = network?.chainId;
+      setChainId(Number(chainId2?.toString()));
+    },
+    [provider]
+  );
+  const value = useMemo14(() => ({
+    busy: false,
+    chainId,
+    connect,
+    error,
+    isConnected,
+    localAddress,
+    provider,
+    providerName,
+    signer: isConnected === true ? signer : void 0,
+    walletProvider
+  }), [
+    chainId,
+    connect,
+    error,
+    isConnected,
+    localAddress,
+    provider,
+    providerName,
+    signer,
+    walletProvider
+  ]);
+  return /* @__PURE__ */ jsx11(
+    EthersContext,
+    {
+      value,
+      children
+    }
+  );
+};
+
+// src/contexts/Ethers/Opera.tsx
+import { useAsyncEffect as useAsyncEffect2 } from "../../async-effect/browser/index.mjs";
+import { EthAddressWrapper as EthAddressWrapper4 } from "@xylabs/eth-address";
+import { BrowserProvider as BrowserProvider7 } from "ethers/providers";
+import { useMemo as useMemo15, useState as useState6 } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var OperaEthersLoader = (props) => {
+  const { children, enabled } = props;
+  const ethereum = globalThis.ethereum;
+  void enabled;
+  const [error, setError] = useState6();
+  const [signer, setSigner] = useState6();
+  const [provider, setProvider] = useState6();
+  const initialAddress = ethereum?.addresses?.[0];
+  const [localAddress, setLocalAddress] = useState6(
+    initialAddress !== void 0 && initialAddress !== "" ? EthAddressWrapper4.fromString(initialAddress) : void 0
+  );
+  const chainId = ethereum?.chainId !== void 0 && ethereum.chainId !== "" ? Number.parseInt(ethereum.chainId) : 1;
+  const isConnected = ethereum?.isConnected?.() ?? false;
+  useAsyncEffect2(
+    async (mounted) => {
+      if (!ethereum) return;
+      void ethereum.enable?.();
+      const operaProvider = new BrowserProvider7(ethereum);
+      const provider2 = operaProvider;
+      const [existingAddress] = await provider2.send("eth_accounts", []) ?? [];
+      if (existingAddress && existingAddress !== localAddress?.toString()) setLocalAddress(EthAddressWrapper4.fromString(existingAddress));
+      if (localAddress) {
+        const signer2 = await operaProvider.getSigner();
+        try {
+          const localAddress2 = EthAddressWrapper4.fromString(await signer2.getAddress());
+          ethereum.autoRefreshOnNetworkChange = false;
+          if (mounted()) {
+            setSigner(signer2);
+            setProvider(provider2);
+            setLocalAddress(localAddress2);
+          }
+        } catch (ex) {
+          if (mounted()) {
+            setError(new Error(`localAddress: ${String(ex)}`));
+          }
+        }
+      }
+    },
+    [ethereum, localAddress]
+  );
+  const value = useMemo15(() => ({
+    busy: false,
+    chainId,
+    error,
+    isConnected,
+    localAddress,
+    provider,
+    signer
+  }), [chainId, error, isConnected, localAddress, provider, signer]);
+  return /* @__PURE__ */ jsx12(
+    EthersContext,
+    {
+      value,
+      children
+    }
+  );
+};
+
+// src/contexts/Ethers/Trust.tsx
+import { useAsyncEffect as useAsyncEffect3 } from "../../async-effect/browser/index.mjs";
+import { EthAddressWrapper as EthAddressWrapper5 } from "@xylabs/eth-address";
+import { BrowserProvider as BrowserProvider8 } from "ethers/providers";
+import { useMemo as useMemo16, useState as useState7 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var TrustEthersLoader = (props) => {
+  const { children, enabled } = props;
+  void enabled;
+  const [error, setError] = useState7();
+  const [signer, setSigner] = useState7();
+  const [localAddress, setLocalAddress] = useState7();
+  const trustProvider = useMemo16(() => globalThis.ethereum ? new BrowserProvider8(globalThis.ethereum) : void 0, []);
+  const chainId = 1;
+  const provider = trustProvider;
+  useAsyncEffect3(
+    async (mounted) => {
+      if (!trustProvider) return;
+      const [existingAddress] = await trustProvider.send("eth_accounts", []) ?? [];
+      if (existingAddress && existingAddress !== localAddress?.toString()) setLocalAddress(EthAddressWrapper5.fromString(existingAddress));
+      if (localAddress) {
+        const localSigner = await trustProvider.getSigner();
+        setSigner(localSigner);
+        try {
+          const localAddress2 = EthAddressWrapper5.fromString(await localSigner.getAddress());
+          if (mounted()) {
+            setLocalAddress(localAddress2);
+          }
+        } catch (ex) {
+          if (mounted()) {
+            setError(new Error(`localAddress: ${String(ex)}`));
+          }
+        }
+      }
+    },
+    [localAddress, trustProvider]
+  );
+  const value = useMemo16(() => ({
+    busy: false,
+    chainId,
+    error,
+    localAddress,
+    provider,
+    signer
+  }), [
+    chainId,
+    error,
+    localAddress,
+    provider,
+    signer
+  ]);
+  return /* @__PURE__ */ jsx13(
+    EthersContext,
+    {
+      value,
+      children
+    }
+  );
+};
+
+// src/contexts/Ethers/Loader.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+var EthersLoader = (props) => {
+  const { children, enabled } = props;
+  const ethereum = globalThis.ethereum;
+  void enabled;
+  if (ethereum?.isMetaMask === true) {
+    return /* @__PURE__ */ jsx14(MetaMaskEthersLoader, { children });
+  }
+  if (ethereum?.isTrust === true) {
+    return /* @__PURE__ */ jsx14(TrustEthersLoader, { children });
+  }
+  if (ethereum?.isMew === true) {
+    return /* @__PURE__ */ jsx14(MyEtherWalletEthersLoader, { children });
+  }
+  if (ethereum?.providerName === "opera") {
+    return /* @__PURE__ */ jsx14(OperaEthersLoader, { children });
+  }
+  if (ethereum) {
+    return /* @__PURE__ */ jsx14(OperaEthersLoader, { children });
+  }
+  return /* @__PURE__ */ jsx14(InfuraEthersLoader, { children });
+};
+
+// src/contexts/Ethers/use.tsx
+import { use } from "react";
+var useEthersContext = () => use(EthersContext);
+
+// src/contexts/NetworkSettings/Context.ts
+import { createContext as createContext2 } from "react";
+var NetworkSettingsContext = createContext2({});
+
+// src/contexts/NetworkSettings/Loader.tsx
+import { EthAddressWrapper as EthAddressWrapper6 } from "@xylabs/eth-address";
+import { useMemo as useMemo17 } from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+var NetworkSettingsLoader = (props) => {
+  const { children, enabled } = props;
+  void enabled;
+  const value = useMemo17(() => ({
+    xyBondAddress: EthAddressWrapper6.fromString("0x1a024A698EEBdB86ccf3fCaF2F589839bdc066AD"),
+    xyFhrMerkleSendAddress: EthAddressWrapper6.fromString("0x46FEEBDffC8076D9E5fd8a11CF1508810472A79f"),
+    xyGovernanceAddress: EthAddressWrapper6.fromString("0x01925d0fFE4a6a6162B51ba611e3D4780Fc2dF42"),
+    xyStakingConsensusAddress: EthAddressWrapper6.fromString("0x0242514106114DEaA99Fd81574142c36Edb03B6D")
+  }), []);
+  return /* @__PURE__ */ jsx15(
+    NetworkSettingsContext,
+    {
+      value,
+      children
+    }
+  );
+};
+
+// src/components/EthAccount/EthAccountBox.tsx
+import { jsx as jsx16, jsxs as jsxs5 } from "react/jsx-runtime";
+var isSxArray = (sx) => Array.isArray(sx);
+var toSxArray = (sx) => sx === void 0 ? [] : isSxArray(sx) ? sx : [sx];
+var EthAccountBox = ({
+  address,
+  icon = false,
+  iconSize = 16,
+  iconOnly = false,
+  shortenedLength,
+  addressLength = "auto",
+  fontFamily = '"Source Code Pro",monospace',
+  removeMargin,
+  sx,
+  ...props
+}) => {
+  const { localAddress } = use2(EthersContext);
+  const theme = useTheme2();
+  const large = useMediaQuery(theme.breakpoints.up("md"));
+  const isLocalAddress = address ? localAddress?.toString() === address.toString() : false;
+  const addressToDisplay = assertEx2(address ?? EthAddressWrapper7.fromString("0x00"), () => "Bad Eth Address");
+  const textToDisplay = address ? addressLength === "long" ? addressToDisplay.toString() : addressLength === "short" ? addressToDisplay.toShortString(shortenedLength) : addressToDisplay[large ? "toString" : "toShortString"]() : "-- --";
+  return /* @__PURE__ */ jsxs5(
+    FlexRow2,
+    {
+      ...props,
+      sx: [{
+        justifyContent: "space-between",
+        alignItems: "stretch"
+      }, ...toSxArray(sx)],
+      children: [
+        icon ? /* @__PURE__ */ jsx16(
+          Identicon,
+          {
+            size: iconSize,
+            value: address?.toHex(),
+            sx: {
+              minWidth: iconSize + Number.parseInt(theme.spacing(1)),
+              bgcolor: theme.vars.palette.secondary.main
+            }
+          }
+        ) : null,
+        iconOnly ? null : /* @__PURE__ */ jsx16(
+          Typography2,
+          {
+            variant: "body1",
+            sx: {
+              alignSelf: "center",
+              marginX: removeMargin === true ? 0 : 1,
+              fontFamily
+            },
+            children: textToDisplay
+          }
+        ),
+        isLocalAddress ? /* @__PURE__ */ jsx16(FlexRow2, { sx: { marginLeft: 0.5 }, children: "(You)" }) : null
+      ]
+    }
+  );
+};
+
+// src/components/EthAccount/EthAccountButton.tsx
+import { ButtonEx } from "../../button/browser/index.mjs";
+import { FlexRow as FlexRow3 } from "../../flexbox/browser/index.mjs";
+import { Identicon as Identicon2 } from "../../identicon/browser/index.mjs";
+import { useTheme as useTheme3 } from "@mui/material";
+import { jsx as jsx17, jsxs as jsxs6 } from "react/jsx-runtime";
+var EthAccountButton = ({
+  address,
+  full,
+  icon = false,
+  iconSize = 16,
+  iconOnly = false,
+  shortenedLength,
+  addressLength = "auto",
+  fontFamily = '"Source Code Pro",monospace',
+  toEtherScan,
+  onClick,
+  ...props
+}) => {
+  const onClickLocal = (event) => {
+    onClick?.(event);
+    if (toEtherScan === true && address) {
+      window.open(`https://etherscan.io/address/${address.toString()}`, "_blank");
+    }
+  };
+  const theme = useTheme3();
+  return /* @__PURE__ */ jsxs6(ButtonEx, { onClick: onClickLocal, title: `0x${address?.toHex()}`, ...props, children: [
+    icon ? /* @__PURE__ */ jsx17(
+      FlexRow3,
+      {
+        sx: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          bottom: 0,
+          paddingX: 0.5,
+          bgcolor: theme.vars.palette.secondary.main
+        },
+        children: /* @__PURE__ */ jsx17(
+          Identicon2,
+          {
+            size: iconSize,
+            value: address?.toHex(),
+            sx: {
+              minHeight: theme.spacing(3),
+              minWidth: theme.spacing(3),
+              bgcolor: theme.vars.palette.secondary.main
+            }
+          }
+        )
+      }
+    ) : null,
+    /* @__PURE__ */ jsx17(
+      EthAccountBox,
+      {
+        address,
+        addressLength,
+        shortenedLength,
+        full,
+        iconSize,
+        iconOnly,
+        sx: {
+          marginLeft: icon ? 3 : 0,
+          fontFamily
+        }
+      }
+    )
+  ] });
+};
+var EthAccount = EthAccountButton;
+
+// src/components/EthBlock.tsx
+import { isNumber } from "@ariestools/sdk";
+import {
+  Box,
+  Link,
+  Typography as Typography3
+} from "@mui/material";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var EthBlock = (props) => {
+  const { block } = props;
+  return isNumber(block) ? /* @__PURE__ */ jsx18(
+    Box,
+    {
+      sx: {
+        alignItems: "center",
+        display: "flex",
+        flexGrow: 1,
+        justifyContent: "center",
+        paddingX: 1
+      },
+      children: /* @__PURE__ */ jsx18(Link, { href: `https://etherscan.io/block/${block}`, target: "_blank", title: `Ethereum Block #${block}`, children: /* @__PURE__ */ jsx18(Typography3, { variant: "caption", children: block }) })
+    }
+  ) : /* @__PURE__ */ jsx18(Box, {});
+};
+
+// src/components/stories/EthWalletSbComponent.tsx
+import { forget as forget7 } from "@ariestools/sdk";
+import { FlexCol as FlexCol3, FlexRow as FlexRow4 } from "../../flexbox/browser/index.mjs";
+import { OpenInNewOutlined } from "@mui/icons-material";
+import {
+  Alert as Alert3,
+  AlertTitle as AlertTitle2,
+  Button as Button2,
+  List,
+  ListItem,
+  Typography as Typography4
+} from "@mui/material";
+import { EthAddressWrapper as EthAddressWrapper8 } from "@xylabs/eth-address";
+import { useMemo as useMemo18, useState as useState8 } from "react";
+import { jsx as jsx19, jsxs as jsxs7 } from "react/jsx-runtime";
+var EthWalletSbComponent = ({
+  connectWallet,
+  connectRefused,
+  chainId,
+  connectError,
+  installed,
+  currentAccount,
+  noIFrames,
+  provider,
+  providerName,
+  signMessage,
+  signer,
+  signerAddress
+}) => {
+  const [signResponse, setSignResponse] = useState8();
+  const [previousProvider, setPreviousProvider] = useState8();
+  if (provider && provider !== previousProvider) {
+    setPreviousProvider(provider);
+    setSignResponse(void 0);
+  }
+  const onSign = () => forget7(
+    (async () => {
+      const signResult = await signMessage?.("test");
+      setSignResponse(EthAddressWrapper8.fromString(signResult));
+    })()
+  );
+  const localAddress = useMemo18(() => currentAccount?.toString(), [currentAccount]);
+  return /* @__PURE__ */ jsxs7(
+    FlexCol3,
+    {
+      sx: {
+        alignItems: "start",
+        gap: 2
+      },
+      children: [
+        noIFrames === true && parent !== globalThis ? /* @__PURE__ */ jsxs7(Alert3, { severity: "warning", children: [
+          /* @__PURE__ */ jsx19(AlertTitle2, { children: "Must test outside of iframe" }),
+          "The",
+          " ",
+          providerName,
+          " ",
+          "wallet does not allow the the permissions for to work from a nested iframe. Look for the",
+          " ",
+          /* @__PURE__ */ jsx19(OpenInNewOutlined, {}),
+          " ",
+          "icon in the upper right."
+        ] }) : null,
+        /* @__PURE__ */ jsxs7(
+          FlexCol3,
+          {
+            sx: {
+              alignItems: "start",
+              gap: 2
+            },
+            children: [
+              globalThis.ethereum ? /* @__PURE__ */ jsx19(Alert3, { children: "Found window.ethereum" }) : null,
+              /* @__PURE__ */ jsxs7(
+                FlexRow4,
+                {
+                  sx: {
+                    justifyContent: "start",
+                    gap: 2
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx19(Button2, { variant: "contained", onClick: () => forget7(connectWallet?.() ?? Promise.resolve([])), children: "Connect" }),
+                    /* @__PURE__ */ jsx19(Button2, { disabled: !currentAccount, variant: "contained", onClick: onSign, children: "Sign" })
+                  ]
+                }
+              ),
+              signResponse ? /* @__PURE__ */ jsxs7(Alert3, { severity: "success", children: [
+                /* @__PURE__ */ jsx19(AlertTitle2, { children: "Sign Response" }),
+                signResponse.toShortString()
+              ] }) : null,
+              /* @__PURE__ */ jsx19(Typography4, { variant: "h6", sx: { mb: 0 }, children: "Provider Details" }),
+              /* @__PURE__ */ jsxs7(List, { sx: { py: 0 }, children: [
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Installed:",
+                  JSON.stringify(installed)
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Chain Id:",
+                  chainId
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Local Address:",
+                  localAddress?.toString()
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "ProviderName:",
+                  providerName
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Provider:",
+                  JSON.stringify(!!provider)
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Signer:",
+                  JSON.stringify(!!signer)
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Signer Address:",
+                  signerAddress?.toShortString()
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Connection Refused:",
+                  JSON.stringify(connectRefused)
+                ] }),
+                /* @__PURE__ */ jsxs7(ListItem, { children: [
+                  "Error:",
+                  connectError?.message ?? connectError?.message
+                ] })
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/TokenAmount/TokenAmount.tsx
+import {
+  assertEx as assertEx3,
+  isBigInt,
+  isString as isString4
+} from "@ariestools/sdk";
+import { ButtonEx as ButtonEx2 } from "../../button/browser/index.mjs";
+import { FlexRow as FlexRow5 } from "../../flexbox/browser/index.mjs";
+import { Typography as Typography5 } from "@mui/material";
+
+// src/components/TokenAmount/img/xyo.svg
+var xyo_default = '<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 238"><defs><style>.cls-1{fill:#999;}</style></defs><title>icon_gray</title><path class="cls-1" d="M74.5,28.33,21.29,120.5,74.5,212.67H180.94l1.76-3,51.46-89.13L180.94,28.33ZM84.65,40.54h78.83L111.65,56.93a15.85,15.85,0,0,1,2,5l59.66-18.81L185.22,101a20.12,20.12,0,0,1,5.36-.78l-10-47.91,37.87,65.53h-7.62a24.21,24.21,0,0,1,.15,2.68,23.29,23.29,0,0,1-.15,2.68h7.62l-39.1,67.75,10.92-50.13A20.57,20.57,0,0,1,185,140l-12.88,59-58.37-19.53a17.61,17.61,0,0,1-1.7,5l47.5,15.92H84.65l4-6.85A20.17,20.17,0,0,1,83.93,191L80,197.78,42.67,133.13l37,32.66a20.52,20.52,0,0,1,3.6-4L36.69,120.66,85,77.79a17.45,17.45,0,0,1-3.19-4.32l-39.46,35L80,43.22l5.56,9.69A17.51,17.51,0,0,1,90.12,50Zm28.24,31.17a16.15,16.15,0,0,1-2.68,4.64l62,35.81a19.74,19.74,0,0,1,2.83-4.54Zm-20,10.51v75.33a18,18,0,0,1,2.47-.16,17.18,17.18,0,0,1,2.89.21v-75a11.21,11.21,0,0,1-1.29,0,17.57,17.57,0,0,1-4.07-.47Zm79.34,46.63-62.08,35.81a18.45,18.45,0,0,1,2.68,4.68l62.23-36a19.68,19.68,0,0,1-2.83-4.53Z"/><path class="cls-1" d="M97,48.58a17.06,17.06,0,1,0,17,17,17.08,17.08,0,0,0-17-17Zm0,5.36a11.7,11.7,0,1,1-11.7,11.69A11.65,11.65,0,0,1,97,53.94Z"/><path class="cls-1" d="M95.37,157.39a18.73,18.73,0,1,0,18.7,18.7,18.74,18.74,0,0,0-18.7-18.7Zm0,5.31A13.4,13.4,0,1,1,82,176.09a13.37,13.37,0,0,1,13.4-13.39Z"/><path class="cls-1" d="M190.73,100.2A20.3,20.3,0,1,0,211,120.5a20.34,20.34,0,0,0-20.3-20.3Zm0,5.36a14.94,14.94,0,1,1-14.94,14.94,14.88,14.88,0,0,1,14.94-14.94Z"/></svg>';
+
+// src/components/TokenAmount/TokenAmount.tsx
+import { jsx as jsx20, jsxs as jsxs8 } from "react/jsx-runtime";
+var placesSplit = (value, places) => {
+  assertEx3(places >= 0, () => "Places has to be >= 0");
+  const factor = BigInt(10 ** Math.abs(places));
+  const remainder = value % factor;
+  const wholeValue = value / factor;
+  return [wholeValue, remainder];
+};
+var placesSplitString = (value, places) => {
+  const [wholeValue, remainder] = placesSplit(value, places);
+  return `${wholeValue}.${remainder.toString().padStart(Math.abs(places), "0")}`;
+};
+var TokenAmount = ({
+  textFontFamily = '"Source Code Pro",monospace',
+  textColor,
+  statusColor,
+  style,
+  amount,
+  places = 18,
+  logo,
+  label,
+  onButtonClick,
+  ...props
+}) => {
+  const amountString = isBigInt(amount) ? placesSplitString(amount, places) : "-";
+  return /* @__PURE__ */ jsx20(
+    ButtonEx2,
+    {
+      style: { backgroundColor: statusColor, ...style },
+      variant: "outlined",
+      onClick: onButtonClick,
+      ...props,
+      children: /* @__PURE__ */ jsxs8(
+        FlexRow5,
+        {
+          busy: amount === void 0,
+          busySize: 16,
+          sx: {
+            justifyContent: "space-between",
+            width: "100%"
+          },
+          children: [
+            /* @__PURE__ */ jsxs8(FlexRow5, { children: [
+              logo === true ? /* @__PURE__ */ jsx20("img", { src: xyo_default, height: 24 }) : null,
+              isString4(label) ? /* @__PURE__ */ jsx20(
+                Typography5,
+                {
+                  noWrap: true,
+                  variant: "caption",
+                  sx: {
+                    marginRight: 1,
+                    marginLeft: logo === true ? 1 : 0,
+                    fontFamily: textFontFamily
+                  },
+                  children: label
+                }
+              ) : null
+            ] }),
+            /* @__PURE__ */ jsx20(
+              Typography5,
+              {
+                color: textColor,
+                noWrap: true,
+                variant: "body1",
+                style: { textTransform: "none" },
+                sx: { fontFamily: textFontFamily },
+                children: amountString
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+};
+
+// src/token/icons/Xl1ColorLogoIcon.tsx
+import { createSvgIcon, SvgIcon } from "@mui/material";
+import { jsx as jsx21, jsxs as jsxs9 } from "react/jsx-runtime";
+var XL1ColorLogoSvgIcon = createSvgIcon(
+  /* @__PURE__ */ jsxs9("svg", { id: "Layer_1", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 256 256", children: [
+    /* @__PURE__ */ jsx21("path", { d: "M154.71,97c.46,2.59,2.5,4.62,5.1,5.05l14.05,2.34,31.71-46.17c4.57-6.65-3.62-14.62-10.14-9.87l-43.68,31.83,2.97,16.82Z", style: { fill: "#8d8fc6" } }),
+    /* @__PURE__ */ jsx21("path", { d: "M173.86,151.62l-14.05,2.34c-2.6.43-4.64,2.45-5.1,5.05l-2.97,16.82,43.68,31.83c6.52,4.75,14.71-3.21,10.14-9.87l-31.71-46.17Z", style: { fill: "#eb407a" } }),
+    /* @__PURE__ */ jsx21("path", { d: "M82.14,104.38l14.05-2.34c2.6-.43,4.64-2.45,5.1-5.05l2.97-16.82-43.68-31.83c-6.52-4.75-14.71,3.21-10.14,9.87l31.71,46.17Z", style: { fill: "#579fd6" } }),
+    /* @__PURE__ */ jsx21("path", { d: "M101.29,159c-.46-2.59-2.5-4.62-5.1-5.05l-14.05-2.34-31.71,46.17c-4.57,6.65,3.62,14.62,10.14,9.87l43.68-31.83-2.97-16.82Z", style: { fill: "#f27046" } }),
+    /* @__PURE__ */ jsx21("path", { d: "M107.33,104l15.94-90.32c.93-5.3,8.53-5.3,9.47,0l15.94,90.32c.35,2.01,1.94,3.57,3.95,3.91l92.24,15.35c5.36.89,5.36,8.59,0,9.49l-92.24,15.35c-2.01.33-3.59,1.9-3.95,3.91l-15.94,90.32c-.93,5.3-8.53,5.3-9.47,0l-15.94-90.32c-.35-2.01-1.94-3.57-3.95-3.91l-92.24-15.35c-5.36-.89-5.36-8.59,0-9.49l92.24-15.35c2.01-.33,3.59-1.9,3.95-3.91Z", style: { fill: "#572aff" } })
+  ] }),
+  "XL1ColorLogoSvgIcon"
+);
+var Xl1ColorLogoIcon = (props) => {
+  return /* @__PURE__ */ jsx21(
+    SvgIcon,
+    {
+      viewBox: "0 0 256 256",
+      ...props,
+      children: /* @__PURE__ */ jsx21(XL1ColorLogoSvgIcon, {})
+    }
+  );
+};
+
+// src/token/icons/XYOColorLogoIcon.tsx
+import { createSvgIcon as createSvgIcon2, SvgIcon as SvgIcon2 } from "@mui/material";
+import { jsx as jsx22, jsxs as jsxs10 } from "react/jsx-runtime";
+var XYOColorLogoSvgIcon = createSvgIcon2(
+  /* @__PURE__ */ jsxs10("svg", { id: "Layer_1", "data-name": "Layer 1", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 256 238", children: [
+    /* @__PURE__ */ jsx22("title", { children: "icon_colored" }),
+    /* @__PURE__ */ jsx22("path", { fill: "#8d8fc6", d: "M74.5,28.33,21.29,120.5,74.5,212.67H180.94l1.76-3,51.46-89.13L180.94,28.33ZM84.65,40.54h78.83L111.65,56.93a15.85,15.85,0,0,1,2,5l59.66-18.81L185.22,101a20.12,20.12,0,0,1,5.36-.78l-10-47.91,37.87,65.53h-7.62a24.21,24.21,0,0,1,.15,2.68,23.29,23.29,0,0,1-.15,2.68h7.62l-39.1,67.75,10.92-50.13A20.57,20.57,0,0,1,185,140l-12.88,59-58.37-19.53a17.61,17.61,0,0,1-1.7,5l47.5,15.92H84.65l4-6.85A20.17,20.17,0,0,1,83.93,191L80,197.78,42.67,133.13l37,32.66a20.52,20.52,0,0,1,3.6-4L36.69,120.66,85,77.79a17.45,17.45,0,0,1-3.19-4.32l-39.46,35L80,43.22l5.56,9.69A17.51,17.51,0,0,1,90.12,50Zm28.24,31.17a16.15,16.15,0,0,1-2.68,4.64l62,35.81a19.74,19.74,0,0,1,2.83-4.54Zm-20,10.51v75.33a18,18,0,0,1,2.47-.16,17.18,17.18,0,0,1,2.89.21v-75a11.21,11.21,0,0,1-1.29,0,17.57,17.57,0,0,1-4.07-.47Zm79.34,46.63-62.08,35.81a18.45,18.45,0,0,1,2.68,4.68l62.23-36a19.68,19.68,0,0,1-2.83-4.53Z" }),
+    /* @__PURE__ */ jsx22("path", { fill: "#579fd6", d: "M97,48.58a17.06,17.06,0,1,0,17,17,17.08,17.08,0,0,0-17-17Zm0,5.36a11.7,11.7,0,1,1-11.7,11.69A11.65,11.65,0,0,1,97,53.94Z" }),
+    /* @__PURE__ */ jsx22("path", { fill: "#f27046", d: "M95.37,157.39a18.73,18.73,0,1,0,18.7,18.7,18.74,18.74,0,0,0-18.7-18.7Zm0,5.31A13.4,13.4,0,1,1,82,176.09a13.37,13.37,0,0,1,13.4-13.39Z" }),
+    /* @__PURE__ */ jsx22("path", { fill: "#eb407a", d: "M190.73,100.2A20.3,20.3,0,1,0,211,120.5a20.34,20.34,0,0,0-20.3-20.3Zm0,5.36a14.94,14.94,0,1,1-14.94,14.94,14.88,14.88,0,0,1,14.94-14.94Z" })
+  ] }),
+  "XL1ColorLogoSvgIcon"
+);
+var XYOColorLogoIcon = (props) => {
+  return /* @__PURE__ */ jsx22(
+    SvgIcon2,
+    {
+      viewBox: "0 0 256 256",
+      ...props,
+      children: /* @__PURE__ */ jsx22(XYOColorLogoSvgIcon, {})
+    }
+  );
+};
+
+// src/token/img/XL1_Logo_Icon_Mainnet.svg
+var XL1_Logo_Icon_Mainnet_default = '<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256"><path d="M154.71,97c.46,2.59,2.5,4.62,5.1,5.05l14.05,2.34,31.71-46.17c4.57-6.65-3.62-14.62-10.14-9.87l-43.68,31.83,2.97,16.82Z" style="fill:#8d8fc6;"/><path d="M173.86,151.62l-14.05,2.34c-2.6.43-4.64,2.45-5.1,5.05l-2.97,16.82,43.68,31.83c6.52,4.75,14.71-3.21,10.14-9.87l-31.71-46.17Z" style="fill:#eb407a;"/><path d="M82.14,104.38l14.05-2.34c2.6-.43,4.64-2.45,5.1-5.05l2.97-16.82-43.68-31.83c-6.52-4.75-14.71,3.21-10.14,9.87l31.71,46.17Z" style="fill:#579fd6;"/><path d="M101.29,159c-.46-2.59-2.5-4.62-5.1-5.05l-14.05-2.34-31.71,46.17c-4.57,6.65,3.62,14.62,10.14,9.87l43.68-31.83-2.97-16.82Z" style="fill:#f27046;"/><path d="M107.33,104l15.94-90.32c.93-5.3,8.53-5.3,9.47,0l15.94,90.32c.35,2.01,1.94,3.57,3.95,3.91l92.24,15.35c5.36.89,5.36,8.59,0,9.49l-92.24,15.35c-2.01.33-3.59,1.9-3.95,3.91l-15.94,90.32c-.93,5.3-8.53,5.3-9.47,0l-15.94-90.32c-.35-2.01-1.94-3.57-3.95-3.91l-92.24-15.35c-5.36-.89-5.36-8.59,0-9.49l92.24-15.35c2.01-.33,3.59-1.9,3.95-3.91Z" style="fill:#572aff;"/></svg>';
+
+// src/token/img/XYO_Logo_Icon.svg
+var XYO_Logo_Icon_default = '<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 238"><defs><style>.cls-1{fill:#8d8fc6;}.cls-2{fill:#579fd6;}.cls-3{fill:#f27046;}.cls-4{fill:#eb407a;}</style></defs><title>icon_colored</title><path class="cls-1" d="M74.5,28.33,21.29,120.5,74.5,212.67H180.94l1.76-3,51.46-89.13L180.94,28.33ZM84.65,40.54h78.83L111.65,56.93a15.85,15.85,0,0,1,2,5l59.66-18.81L185.22,101a20.12,20.12,0,0,1,5.36-.78l-10-47.91,37.87,65.53h-7.62a24.21,24.21,0,0,1,.15,2.68,23.29,23.29,0,0,1-.15,2.68h7.62l-39.1,67.75,10.92-50.13A20.57,20.57,0,0,1,185,140l-12.88,59-58.37-19.53a17.61,17.61,0,0,1-1.7,5l47.5,15.92H84.65l4-6.85A20.17,20.17,0,0,1,83.93,191L80,197.78,42.67,133.13l37,32.66a20.52,20.52,0,0,1,3.6-4L36.69,120.66,85,77.79a17.45,17.45,0,0,1-3.19-4.32l-39.46,35L80,43.22l5.56,9.69A17.51,17.51,0,0,1,90.12,50Zm28.24,31.17a16.15,16.15,0,0,1-2.68,4.64l62,35.81a19.74,19.74,0,0,1,2.83-4.54Zm-20,10.51v75.33a18,18,0,0,1,2.47-.16,17.18,17.18,0,0,1,2.89.21v-75a11.21,11.21,0,0,1-1.29,0,17.57,17.57,0,0,1-4.07-.47Zm79.34,46.63-62.08,35.81a18.45,18.45,0,0,1,2.68,4.68l62.23-36a19.68,19.68,0,0,1-2.83-4.53Z"/><path class="cls-2" d="M97,48.58a17.06,17.06,0,1,0,17,17,17.08,17.08,0,0,0-17-17Zm0,5.36a11.7,11.7,0,1,1-11.7,11.69A11.65,11.65,0,0,1,97,53.94Z"/><path class="cls-3" d="M95.37,157.39a18.73,18.73,0,1,0,18.7,18.7,18.74,18.74,0,0,0-18.7-18.7Zm0,5.31A13.4,13.4,0,1,1,82,176.09a13.37,13.37,0,0,1,13.4-13.39Z"/><path class="cls-4" d="M190.73,100.2A20.3,20.3,0,1,0,211,120.5a20.34,20.34,0,0,0-20.3-20.3Zm0,5.36a14.94,14.94,0,1,1-14.94,14.94,14.88,14.88,0,0,1,14.94-14.94Z"/></svg>';
+
+// src/token/img/index.ts
+var formatSvgAsDataUrl = (svgString) => {
+  const base64ImagePrefix = "data:image/svg+xml;utf8,";
+  return typeof svgString === "string" && svgString.trim().startsWith("<svg") ? `${base64ImagePrefix}${encodeURIComponent(svgString)}` : svgString;
+};
+var imgXYOLogoSrcDataUrl = formatSvgAsDataUrl(XYO_Logo_Icon_default);
+var imgXL1LogoSrcDataUrl = formatSvgAsDataUrl(XL1_Logo_Icon_Mainnet_default);
+
+// src/token/StandardTokenRow.tsx
+import { isUndefinedOrNull } from "@ariestools/sdk";
+import { Stack, Typography as Typography6 } from "@mui/material";
+
+// src/token/TokenAvatar.tsx
+import {
+  Avatar,
+  useTheme as useTheme4
+} from "@mui/material";
+import { jsx as jsx23 } from "react/jsx-runtime";
+var TokenAvatar = ({
+  imgSrc,
+  imgAlt,
+  scale = 1.6,
+  sx,
+  typographyVariant = "inherit",
+  ...props
+}) => {
+  const theme = useTheme4();
+  const v = typographyVariant === "inherit" ? "body1" : typographyVariant;
+  const typ = theme.typography[v];
+  const base2 = typeof typ?.fontSize === "number" ? typ.fontSize : typeof typ?.fontSize === "string" && typ.fontSize.endsWith("rem") ? Number(typ.fontSize) * (theme.typography.htmlFontSize ?? 16) : typeof typ?.fontSize === "string" ? Number(typ.fontSize) : 16;
+  const size = Math.max(0, Math.round(base2 * scale));
+  return /* @__PURE__ */ jsx23(
+    Avatar,
+    {
+      alt: imgAlt,
+      src: imgSrc,
+      sx: {
+        width: size,
+        height: size,
+        ...sx
+      },
+      ...props
+    }
+  );
+};
+
+// src/token/StandardTokenRow.tsx
+import { jsx as jsx24, jsxs as jsxs11 } from "react/jsx-runtime";
+var StandardTokenRow = ({
+  currency,
+  customSymbol,
+  value,
+  textVariant,
+  textWeight = 300,
+  children,
+  tokenAvatarProps,
+  valueOverride,
+  symbolOverride,
+  ...stackProps
+}) => {
+  const { sx } = stackProps;
+  return /* @__PURE__ */ jsxs11(
+    Stack,
+    {
+      direction: "row",
+      spacing: 0.5,
+      ...stackProps,
+      sx: { alignItems: "center", ...sx },
+      children: [
+        currency === "xyo" ? /* @__PURE__ */ jsx24(
+          TokenAvatar,
+          {
+            imgAlt: "xyo-token-logo",
+            imgSrc: imgXYOLogoSrcDataUrl,
+            ...tokenAvatarProps
+          }
+        ) : /* @__PURE__ */ jsx24(
+          TokenAvatar,
+          {
+            imgAlt: "xl1-token-logo",
+            imgSrc: imgXL1LogoSrcDataUrl,
+            ...tokenAvatarProps
+          }
+        ),
+        valueOverride ?? /* @__PURE__ */ jsx24(
+          Typography6,
+          {
+            variant: isUndefinedOrNull(textVariant) ? "body1" : textVariant,
+            sx: {
+              fontWeight: textWeight,
+              lineHeight: 1
+            },
+            children: value
+          }
+        ),
+        symbolOverride ?? /* @__PURE__ */ jsx24(
+          Typography6,
+          {
+            variant: isUndefinedOrNull(textVariant) ? "body1" : textVariant,
+            color: "textSecondary",
+            sx: {
+              fontWeight: textWeight,
+              lineHeight: 1,
+              textTransform: "uppercase"
+            },
+            children: customSymbol ?? currency
+          }
+        ),
+        children
+      ]
+    }
+  );
+};
+export {
+  AccountsChangedEventName,
+  ChainChangedEventName,
+  ConstrainedImage,
+  EIP1193Events,
+  EIP6963Connector,
+  EMPTY_ARRAY,
+  EthAccount,
+  EthAccountBox,
+  EthAccountButton,
+  EthBlock,
+  EthWalletApiInstance,
+  EthWalletConnections,
+  EthWalletConnectorBase,
+  EthWalletSbComponent,
+  EthersContext,
+  EthersLoader,
+  InfuraEthersLoader,
+  MetaMaskConnector,
+  MetaMaskEthersLoader,
+  MyEtherWalletEthersLoader,
+  NetworkSettingsContext,
+  NetworkSettingsLoader,
+  OperaEthersLoader,
+  PhantomConnector,
+  StandardTokenRow,
+  TokenAmount,
+  TokenAvatar,
+  TrustConnector,
+  TrustEthersLoader,
+  WalletDiscoveryMenuItem,
+  WalletDiscoveryMenuItemInner,
+  WalletDiscoveryPaper,
+  WalletOverviewCard,
+  WalletOverviewCardActions,
+  WalletOverviewCardContent,
+  WalletOverviewCardHeader,
+  WalletsDiscoveredMenuItems,
+  XL1_Logo_Icon_Mainnet_default as XL1ColorLogoIconSvg,
+  XYOColorLogoIcon,
+  XYO_Logo_Icon_default as XYOColorLogoIconSvg,
+  Xl1ColorLogoIcon,
+  findChainName,
+  formatSvgAsDataUrl,
+  imgXL1LogoSrcDataUrl,
+  imgXYOLogoSrcDataUrl,
+  infuraKey,
+  isEIP6963AnnounceProviderEvent,
+  useChainId,
+  useCoinbaseWallet,
+  useConnectWallet,
+  useCurrentAccount,
+  useCurrentAccountExternal,
+  useEip6963Wallet,
+  useEthWallet,
+  useEthWalletApiInstance,
+  useEthWalletInstance,
+  useEthersContext,
+  useInfuraProvider,
+  useMetaMask,
+  useNavigateToEthAddress,
+  usePhantomWallet,
+  useProvider,
+  useSigner,
+  useTrustWallet,
+  useTryMethodCalls,
+  useWalletDiscovery
+};