@xyo-network/react-chain-provider 1.20.1 → 1.20.3

package/dist/browser/index.mjs

@@ -27,9 +27,9 @@ var ConnectedAccount = /* @__PURE__ */ __name(({ address }) => {
 // src/components/connected/ConnectAccountsStack.tsx
 import { Alert, AlertTitle, Button, Stack as Stack2, Typography as Typography2 } from "@mui/material";
 import { ButtonEx } from "@xylabs/react-button";
-import { isDefined as isDefined9, isUndefined as isUndefined8 } from "@xylabs/sdk-js";
-import { ErrorRender } from "@xyo-network/react-error";
-import React2, { useEffect as useEffect4 } from "react";
+import { isDefined as isDefined10, isUndefined as isUndefined8 } from "@xylabs/sdk-js";
+import { ErrorRender as ErrorRender2 } from "@xyo-network/react-error";
+import React5, { useEffect as useEffect7 } from "react";
 
 // src/hooks/account/helpers/formatAccountBalanceHistory.ts
 import { hexToBigInt } from "@xylabs/sdk-js";
@@ -87,6 +87,24 @@ var balanceForRange = /* @__PURE__ */ __name((address, results) => {
   ];
 }, "balanceForRange");
 
+// src/lib/buildGateway.ts
+import { assertEx, isDefined } from "@xylabs/sdk-js";
+import { basicRemoteRunnerLocator, basicRemoteViewerLocator } from "@xyo-network/chain-orchestration";
+import { DefaultNetworks, NetworkDataLakeUrls, XyoGatewayMoniker } from "@xyo-network/xl1-sdk";
+var buildGateway = /* @__PURE__ */ __name(async (gatewayName, account) => {
+  const network = DefaultNetworks.find((network2) => network2.id === gatewayName);
+  const resolvedNetwork = assertEx(network, () => `No network found for id ${gatewayName}`);
+  const remoteConfig = {
+    rpc: {
+      protocol: "http",
+      url: `${resolvedNetwork.url}/rpc`
+    }
+  };
+  const dataLakeEndpoint = NetworkDataLakeUrls[gatewayName];
+  const locator = isDefined(account) ? await basicRemoteRunnerLocator(gatewayName, remoteConfig, account, dataLakeEndpoint) : await basicRemoteViewerLocator(gatewayName, remoteConfig, dataLakeEndpoint);
+  return await locator.getInstance(XyoGatewayMoniker);
+}, "buildGateway");
+
 // src/lib/findMinimumBlock.ts
 var findMinimumBlock = /* @__PURE__ */ __name((history) => {
   if (history.length === 0) return 0;
@@ -137,7 +155,7 @@ var useAccountBalanceHistory = /* @__PURE__ */ __name((address, viewer, maxPage
   ]);
 }, "useAccountBalanceHistory");
 
-// src/hooks/client/useClient.ts
+// src/hooks/client/useClientFromWallet.ts
 import { isNull as isNull2 } from "@xylabs/sdk-js";
 import { useCallback, useEffect, useSyncExternalStore } from "react";
 
@@ -176,7 +194,7 @@ async function getXyoClient(timeout = CLIENT_LISTENER_TIMEOUT) {
 __name(getXyoClient, "getXyoClient");
 
 // src/hooks/helpers/transaction/Confirmation.ts
-import { assertEx, delay, forget, isDefined, isNull } from "@xylabs/sdk-js";
+import { assertEx as assertEx2, delay, forget, isDefined as isDefined2, isNull } from "@xylabs/sdk-js";
 var TransactionConfirmationStatus = class _TransactionConfirmationStatus {
   static {
     __name(this, "TransactionConfirmationStatus");
@@ -187,10 +205,10 @@ var TransactionConfirmationStatus = class _TransactionConfirmationStatus {
     this._params = params;
   }
   get exp() {
-    return assertEx(this.transaction[0].exp, () => "exp is not found, transaction is not set");
+    return assertEx2(this.transaction[0].exp, () => "exp is not found, transaction is not set");
   }
   get nbf() {
-    return assertEx(this.transaction[0].nbf, () => "nbf is not found, transaction is not set");
+    return assertEx2(this.transaction[0].nbf, () => "nbf is not found, transaction is not set");
   }
   get onStatusUpdate() {
     return this._params.onStatusUpdate;
@@ -214,7 +232,7 @@ var TransactionConfirmationStatus = class _TransactionConfirmationStatus {
     this.active = true;
     try {
       const currentBlockNumber = await this.viewer.currentBlockNumber();
-      while (isDefined(currentBlockNumber) && this.active) {
+      while (isDefined2(currentBlockNumber) && this.active) {
         await this.checkBlock(currentBlockNumber);
         await delay(1e3);
       }
@@ -279,7 +297,7 @@ var TransactionConfirmationStatus = class _TransactionConfirmationStatus {
   }
 };
 
-// src/hooks/client/useClient.ts
+// src/hooks/client/useClientFromWallet.ts
 var currentState = {
   client: void 0,
   error: null,
@@ -333,7 +351,7 @@ var subscribe = /* @__PURE__ */ __name((listener, timeout) => {
   };
 }, "subscribe");
 var getSnapshot = /* @__PURE__ */ __name(() => currentState, "getSnapshot");
-var useClient = /* @__PURE__ */ __name((timeout) => {
+var useClientFromWallet = /* @__PURE__ */ __name((timeout) => {
   const subscribeWithTimeout = useCallback((listener) => subscribe(listener, timeout), [
     timeout
   ]);
@@ -355,11 +373,12 @@ var useClient = /* @__PURE__ */ __name((timeout) => {
     };
   });
   return clientState;
-}, "useClient");
+}, "useClientFromWallet");
+var useClient = useClientFromWallet;
 
 // src/hooks/client/permissions/usePermissions.ts
 var usePermissions = /* @__PURE__ */ __name(() => {
-  const { client, isLoading, error, timedout } = useClient();
+  const { client, isLoading, error, timedout } = useClientFromWallet();
   const permissions = client?.permissions;
   return {
     permissions,
@@ -371,15 +390,15 @@ var usePermissions = /* @__PURE__ */ __name(() => {
 
 // src/hooks/client/permissions/usePermissionsAccounts.ts
 import { usePromise as usePromise2 } from "@xylabs/react-promise";
-import { isArray, isDefined as isDefined3, isDefinedNotNull, isString } from "@xylabs/sdk-js";
+import { isArray, isDefined as isDefined4, isDefinedNotNull, isString } from "@xylabs/sdk-js";
 
 // src/hooks/client/helpers/findCaveat.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
 var findCaveat = /* @__PURE__ */ __name(async (permissions, targetCapability, targetCaveatType) => {
   const existingPermissions = await permissions.getPermissions();
-  if (isDefined2(existingPermissions) && existingPermissions.length > 0) {
+  if (isDefined3(existingPermissions) && existingPermissions.length > 0) {
     const foundPermissions = existingPermissions.find((p) => p.parentCapability === targetCapability);
-    if (isDefined2(foundPermissions)) {
+    if (isDefined3(foundPermissions)) {
       return foundPermissions.caveats?.find((caveat) => caveat.type === targetCaveatType)?.value ?? [];
     }
   }
@@ -388,7 +407,7 @@ var findCaveat = /* @__PURE__ */ __name(async (permissions, targetCapability, ta
 
 // src/hooks/client/permissions/usePermissionsAccounts.ts
 var validateRestrictedAccounts = /* @__PURE__ */ __name((restrictedAccounts) => {
-  if (isDefined3(restrictedAccounts)) {
+  if (isDefined4(restrictedAccounts)) {
     if (isArray(restrictedAccounts) && restrictedAccounts.every(isString)) {
       return restrictedAccounts;
     }
@@ -402,7 +421,7 @@ var useAccountPermissions = /* @__PURE__ */ __name(() => {
   const { permissions, error } = usePermissions();
   return usePromise2(async () => {
     if (isDefinedNotNull(error)) throw error;
-    if (isDefined3(permissions)) {
+    if (isDefined4(permissions)) {
       const restrictedAccounts = await findCaveat(
         permissions,
         // TODO - extract to constant in protocol package
@@ -416,13 +435,13 @@ var useAccountPermissions = /* @__PURE__ */ __name(() => {
   ]);
 }, "useAccountPermissions");
 
-// src/hooks/client/useGateway.ts
-import { isDefined as isDefined4, isNull as isNull3 } from "@xylabs/sdk-js";
-var useGateway = /* @__PURE__ */ __name((gatewayName, timeout) => {
-  const { client, isLoading, error, timedout } = useClient(timeout);
+// src/hooks/client/useGatewayFromWallet.ts
+import { isDefined as isDefined5, isNull as isNull3 } from "@xylabs/sdk-js";
+var useGatewayFromWallet = /* @__PURE__ */ __name((gatewayName, timeout) => {
+  const { client, isLoading, error, timedout } = useClientFromWallet(timeout);
   const resolveGateway = /* @__PURE__ */ __name(() => {
     if (isNull3(client)) return null;
-    if (timedout && !isLoading && isDefined4(gatewayName)) {
+    if (timedout && !isLoading && isDefined5(gatewayName)) {
       return null;
     }
     return client?.gateways?.[gatewayName];
@@ -433,17 +452,266 @@ var useGateway = /* @__PURE__ */ __name((gatewayName, timeout) => {
     error,
     timedout
   };
-}, "useGateway");
+}, "useGatewayFromWallet");
+var useGateway = useGatewayFromWallet;
+
+// src/contexts/current-block/context.ts
+import { createContextEx } from "@xylabs/react-shared";
+var XL1CurrentBlockContext = createContextEx();
+
+// src/contexts/current-block/Provider.tsx
+import React2, { useMemo } from "react";
+
+// src/contexts/current-block/usePollCurrentBlock.ts
+import { isDefinedNotNull as isDefinedNotNull2, isUndefinedOrNull } from "@xylabs/sdk-js";
+import { startTransition, useEffect as useEffect2, useState } from "react";
+var DEFAULT_POLL_INTERVAL = 1e4;
+var usePollCurrentBlock = /* @__PURE__ */ __name((viewer, interval = DEFAULT_POLL_INTERVAL, pause = false) => {
+  const [currentBlock, setCurrentBlock] = useState(null);
+  const [error, setError] = useState();
+  useEffect2(() => {
+    let isMounted = true;
+    const fetchBlock = /* @__PURE__ */ __name(async () => {
+      if (isDefinedNotNull2(viewer)) {
+        try {
+          const block = await viewer.currentBlock();
+          if (isMounted) {
+            startTransition(() => {
+              setCurrentBlock((existingBlock) => {
+                if (isUndefinedOrNull(existingBlock)) {
+                  return block;
+                }
+                if (isDefinedNotNull2(block) && existingBlock?.[0].block !== block[0].block) {
+                  return block;
+                }
+                return existingBlock;
+              });
+            });
+          }
+        } catch (err) {
+          startTransition(() => {
+            setError(err);
+          });
+        }
+      }
+    }, "fetchBlock");
+    void fetchBlock();
+    const id = setInterval(() => {
+      if (!pause) {
+        void fetchBlock();
+      }
+    }, interval);
+    return () => {
+      isMounted = false;
+      clearInterval(id);
+    };
+  }, [
+    viewer,
+    interval,
+    pause
+  ]);
+  return [
+    currentBlock,
+    error
+  ];
+}, "usePollCurrentBlock");
+
+// src/contexts/current-block/Provider.tsx
+var DEFAULT_POLLING_INTERVAL = 1e4;
+var XL1CurrentBlockProvider = /* @__PURE__ */ __name(({ pollingConfig, viewer, children }) => {
+  const { interval } = useMemo(() => pollingConfig || {
+    interval: DEFAULT_POLLING_INTERVAL
+  }, [
+    pollingConfig
+  ]);
+  const [currentBlock, currentBlockError] = usePollCurrentBlock(viewer, interval);
+  const value = useMemo(() => ({
+    block: currentBlock,
+    blockNumber: currentBlock?.[0].block,
+    chain: currentBlock?.[0].chain,
+    error: currentBlockError,
+    pollingConfig,
+    provided: true
+  }), [
+    currentBlock,
+    currentBlockError,
+    pollingConfig
+  ]);
+  return /* @__PURE__ */ React2.createElement(XL1CurrentBlockContext, {
+    value
+  }, children);
+}, "XL1CurrentBlockProvider");
+
+// src/contexts/current-block/use.ts
+import { useContextEx } from "@xylabs/react-shared";
+var useXl1CurrentBlockContext = /* @__PURE__ */ __name((required = true) => useContextEx(XL1CurrentBlockContext, "XL1CurrentBlock", required), "useXl1CurrentBlockContext");
+
+// src/contexts/gateway/context.ts
+import { createContextEx as createContextEx2 } from "@xylabs/react-shared";
+var GatewayContext = createContextEx2();
+
+// src/contexts/gateway/Provider.tsx
+import { isDefinedNotNull as isDefinedNotNull3, isNull as isNull4 } from "@xylabs/sdk-js";
+import { ErrorRender } from "@xyo-network/react-error";
+import React4, { useEffect as useEffect4, useMemo as useMemo3, useState as useState3 } from "react";
+
+// src/contexts/in-page-gateways/context.ts
+import { createContextEx as createContextEx3 } from "@xylabs/react-shared";
+var InPageGatewaysContext = createContextEx3();
+
+// src/contexts/in-page-gateways/Provider.tsx
+import { DefaultNetworks as DefaultNetworks2 } from "@xyo-network/xl1-sdk";
+import React3, { startTransition as startTransition2, useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo2, useState as useState2 } from "react";
+var InPageGatewaysProvider = /* @__PURE__ */ __name(({ account, children }) => {
+  const [gateways, setGateways] = useState2({});
+  const [errors, setErrors] = useState2({});
+  const [previousAccount, setPreviousAccount] = useState2(account);
+  const clearAll = useCallback2(() => {
+    setGateways({});
+    setErrors({});
+  }, []);
+  if (previousAccount !== account) {
+    clearAll();
+    setPreviousAccount(account);
+  }
+  useEffect3(() => {
+    let cancelled = false;
+    const buildAll = /* @__PURE__ */ __name(async () => {
+      const results = await Promise.allSettled(DefaultNetworks2.map(async (network) => {
+        const gateway = await buildGateway(network.id, account);
+        return {
+          id: network.id,
+          gateway
+        };
+      }));
+      if (cancelled) return;
+      const nextGateways = {};
+      const nextErrors = {};
+      for (const [index, result] of results.entries()) {
+        const networkId = DefaultNetworks2[index].id;
+        if (result.status === "fulfilled") {
+          nextGateways[networkId] = result.value.gateway;
+        } else {
+          nextErrors[networkId] = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        }
+      }
+      startTransition2(() => {
+        setGateways(nextGateways);
+        setErrors(nextErrors);
+      });
+    }, "buildAll");
+    void buildAll();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    account
+  ]);
+  const value = useMemo2(() => {
+    const value2 = {
+      clearAll,
+      errors,
+      gateways,
+      provided: true
+    };
+    return value2;
+  }, [
+    clearAll,
+    errors,
+    gateways
+  ]);
+  return /* @__PURE__ */ React3.createElement(InPageGatewaysContext, {
+    value
+  }, children);
+}, "InPageGatewaysProvider");
+
+// src/contexts/in-page-gateways/use.ts
+import { useContextEx as useContextEx2 } from "@xylabs/react-shared";
+var useProvidedInPageGateways = /* @__PURE__ */ __name((required = true) => useContextEx2(InPageGatewaysContext, "InPageGateways", required), "useProvidedInPageGateways");
+
+// src/contexts/gateway/Provider.tsx
+var GatewayProvider = /* @__PURE__ */ __name(({ gatewayName, children }) => {
+  const [defaultGateway, setDefaultGateway] = useState3();
+  const [gateways, setGateways] = useState3({
+    inPageGateway: void 0,
+    walletGateway: void 0
+  });
+  const { gateway: gatewayFromWallet, error: gatewayFromWalletError } = useGatewayFromWallet(gatewayName);
+  const { gateways: allGateways, errors: allGatewayErrors, clearAll } = useProvidedInPageGateways(true);
+  const gatewayFromConfig = gatewayName ? allGateways[gatewayName] : void 0;
+  const gatewayFromConfigError = gatewayName ? allGatewayErrors[gatewayName] : void 0;
+  useEffect4(() => {
+    if (isNull4(gatewayFromWallet)) {
+      setDefaultGateway(gatewayFromConfig);
+      setGateways({
+        inPageGateway: gatewayFromConfig,
+        walletGateway: null
+      });
+    } else if (isDefinedNotNull3(gatewayFromWallet)) {
+      setDefaultGateway(gatewayFromWallet);
+      setGateways({
+        inPageGateway: gatewayFromConfig,
+        walletGateway: gatewayFromWallet
+      });
+    }
+  }, [
+    gatewayFromConfig,
+    gatewayFromWallet
+  ]);
+  const value = useMemo3(() => {
+    const value2 = {
+      defaultGateway,
+      error: gatewayFromWalletError || gatewayFromConfigError,
+      gateways,
+      provided: true,
+      resetGatewaysFromConfig: clearAll
+    };
+    return value2;
+  }, [
+    defaultGateway,
+    gatewayFromWalletError,
+    gatewayFromConfigError,
+    gateways,
+    clearAll
+  ]);
+  return /* @__PURE__ */ React4.createElement(GatewayContext, {
+    value
+  }, /* @__PURE__ */ React4.createElement(ErrorRender, {
+    error: gatewayFromConfigError
+  }), children);
+}, "GatewayProvider");
+
+// src/contexts/gateway/use.ts
+import { useContextEx as useContextEx3 } from "@xylabs/react-shared";
+var useProvidedGateway = /* @__PURE__ */ __name((required = true) => useContextEx3(GatewayContext, "Gateway", required), "useProvidedGateway");
+
+// src/hooks/gateway/useNetwork.ts
+var useNetworkFromGateway = /* @__PURE__ */ __name(() => {
+  const { defaultGateway } = useProvidedGateway();
+  return defaultGateway?.connection?.network;
+}, "useNetworkFromGateway");
+
+// src/hooks/gateway/useRunner.ts
+var useRunnerFromGateway = /* @__PURE__ */ __name(() => {
+  const { defaultGateway } = useProvidedGateway();
+  return defaultGateway?.connection?.runner;
+}, "useRunnerFromGateway");
+
+// src/hooks/gateway/useViewer.ts
+var useViewerFromGateway = /* @__PURE__ */ __name(() => {
+  const { defaultGateway } = useProvidedGateway();
+  return defaultGateway?.connection?.viewer;
+}, "useViewerFromGateway");
 
 // src/hooks/useAddressBalance.ts
 import { usePromise as usePromise3 } from "@xylabs/react-promise";
-import { isUndefined as isUndefined3, isUndefinedOrNull } from "@xylabs/sdk-js";
+import { isUndefined as isUndefined3, isUndefinedOrNull as isUndefinedOrNull2 } from "@xylabs/sdk-js";
 import { ShiftedBigInt } from "@xyo-network/xl1-sdk";
-import { useMemo, useRef, useState } from "react";
+import { useMemo as useMemo4, useRef, useState as useState4 } from "react";
 var useAddressBalance = /* @__PURE__ */ __name((address, viewer, refresh) => {
-  const [balancesResult, setBalancesResult] = useState();
-  const [loading, setLoading] = useState(false);
-  const [balancesError, setBalancesError] = useState();
+  const [balancesResult, setBalancesResult] = useState4();
+  const [loading, setLoading] = useState4(false);
+  const [balancesError, setBalancesError] = useState4();
   const balancePromiseRef = useRef(null);
   usePromise3(async () => {
     if (isUndefined3(viewer) || isUndefined3(address)) return;
@@ -470,14 +738,14 @@ var useAddressBalance = /* @__PURE__ */ __name((address, viewer, refresh) => {
     viewer,
     refresh
   ]);
-  useMemo(() => {
+  useMemo4(() => {
     if (balancesError) {
       setLoading(false);
     }
   }, [
     balancesError
   ]);
-  const shiftedBigInt = useMemo(() => {
+  const shiftedBigInt = useMemo4(() => {
     if (typeof balancesResult !== "bigint") return;
     return new ShiftedBigInt(balancesResult, {
       places: 18,
@@ -489,13 +757,13 @@ var useAddressBalance = /* @__PURE__ */ __name((address, viewer, refresh) => {
   }, [
     balancesResult
   ]);
-  const balanceIntlFriendly = useMemo(() => {
+  const balanceIntlFriendly = useMemo4(() => {
     return shiftedBigInt?.toFullString();
   }, [
     shiftedBigInt
   ]);
-  const shortBalanceIntlFriendly = useMemo(() => {
-    return isUndefinedOrNull(balancesResult) ? void 0 : balancesResult < 1000000000000n && balancesResult > 0n ? "<0.00001" : shiftedBigInt?.toShortString();
+  const shortBalanceIntlFriendly = useMemo4(() => {
+    return isUndefinedOrNull2(balancesResult) ? void 0 : balancesResult < 1000000000000n && balancesResult > 0n ? "<0.00001" : shiftedBigInt?.toShortString();
   }, [
     balancesResult,
     shiftedBigInt
@@ -512,21 +780,21 @@ var useAddressBalance = /* @__PURE__ */ __name((address, viewer, refresh) => {
 
 // src/hooks/useConfirmTransactionBase.ts
 import { usePromise as usePromise4 } from "@xylabs/react-promise";
-import { forget as forget2, isDefined as isDefined5, isHash } from "@xylabs/sdk-js";
+import { forget as forget2, isDefined as isDefined6, isHash } from "@xylabs/sdk-js";
 import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { useEffect as useEffect2, useState as useState2 } from "react";
+import { useEffect as useEffect5, useState as useState5 } from "react";
 var useConfirmTransactionBase = /* @__PURE__ */ __name((transaction, onBroadcast, onStatusUpdate, runner, viewer) => {
-  const [status, setStatus] = useState2();
+  const [status, setStatus] = useState5();
   const onStatusUpdateLocal = /* @__PURE__ */ __name((newStatus) => {
     setStatus(newStatus);
     onStatusUpdate?.(newStatus);
   }, "onStatusUpdateLocal");
   const [transactionConfirmationStatus, transactionConfirmationError] = usePromise4(async () => {
-    const hasRunner = isDefined5(runner);
+    const hasRunner = isDefined6(runner);
     if (transaction && viewer) {
       const hash = hasRunner ? await runner.broadcastTransaction(transaction) : await PayloadBuilder.hash(transaction[0]);
       if (isHash(hash)) {
-        if (hasRunner && isDefined5(onBroadcast)) onBroadcast(hash);
+        if (hasRunner && isDefined6(onBroadcast)) onBroadcast(hash);
         const params = {
           onStatusUpdate: onStatusUpdateLocal,
           transaction,
@@ -545,7 +813,7 @@ var useConfirmTransactionBase = /* @__PURE__ */ __name((transaction, onBroadcast
     runner,
     viewer
   ]);
-  useEffect2(() => {
+  useEffect5(() => {
     return () => {
       if (transactionConfirmationStatus) {
         forget2(transactionConfirmationStatus.stop());
@@ -562,18 +830,18 @@ var useConfirmTransactionBase = /* @__PURE__ */ __name((transaction, onBroadcast
 
 // src/hooks/useConnectAccount.ts
 import { asAddress } from "@xylabs/sdk-js";
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
 import { MainNetwork } from "@xyo-network/xl1-sdk";
-import { useCallback as useCallback2, useState as useState3 } from "react";
+import { useCallback as useCallback3, useState as useState6 } from "react";
 var useConnectAccount = /* @__PURE__ */ __name((gatewayName = MainNetwork.id, timeout) => {
-  const [connectError, setConnectError] = useState3();
-  const { gateway, error, timedout } = useGateway(gatewayName, timeout);
+  const [connectError, setConnectError] = useState6();
+  const { gateway, error, timedout } = useGatewayFromWallet(gatewayName, timeout);
   const [accountPermissions, accountPermissionsError] = useAccountPermissions();
-  const [address, setAddress] = useState3();
-  const connectSigner = useCallback2(async () => {
+  const [address, setAddress] = useState6();
+  const connectSigner = useCallback3(async () => {
     try {
       setConnectError(void 0);
-      const assertedGateway = assertEx2(gateway, () => `Gateway ${gatewayName} is not available`);
+      const assertedGateway = assertEx3(gateway, () => `Gateway ${gatewayName} is not available`);
       const signer = assertedGateway.signer;
       const address2 = await signer.address();
       setAddress(address2);
@@ -596,10 +864,10 @@ var useConnectAccount = /* @__PURE__ */ __name((gatewayName = MainNetwork.id, ti
 
 // src/hooks/useCurrentBlock.ts
 import { usePromise as usePromise5 } from "@xylabs/react-promise";
-import { isDefinedNotNull as isDefinedNotNull2 } from "@xylabs/sdk-js";
+import { isDefinedNotNull as isDefinedNotNull4 } from "@xylabs/sdk-js";
 var useCurrentBlock = /* @__PURE__ */ __name((refresh = 1, viewer) => {
   return usePromise5(async () => {
-    if (isDefinedNotNull2(viewer) && refresh > 0) {
+    if (isDefinedNotNull4(viewer) && refresh > 0) {
       const block = await viewer.currentBlock();
       return block;
     }
@@ -608,6 +876,18 @@ var useCurrentBlock = /* @__PURE__ */ __name((refresh = 1, viewer) => {
     refresh
   ]);
 }, "useCurrentBlock");
+var useCurrentBlockFromGateway = /* @__PURE__ */ __name((refresh = 1) => {
+  const viewer = useViewerFromGateway();
+  return usePromise5(async () => {
+    if (isDefinedNotNull4(viewer) && refresh > 0) {
+      const block = await viewer.currentBlock();
+      return block;
+    }
+  }, [
+    viewer,
+    refresh
+  ]);
+}, "useCurrentBlockFromGateway");
 
 // src/hooks/useHttpRpcRunner.ts
 import { usePromise as usePromise6 } from "@xylabs/react-promise";
@@ -635,9 +915,9 @@ var useHttpRpcRunner = /* @__PURE__ */ __name((url) => {
 // src/hooks/useNetwork.ts
 import { isUndefined as isUndefined5 } from "@xylabs/sdk-js";
 import { SimpleXyoNetwork } from "@xyo-network/xl1-sdk";
-import { useMemo as useMemo2 } from "react";
+import { useMemo as useMemo5 } from "react";
 var useNetwork = /* @__PURE__ */ __name((id) => {
-  const network = useMemo2(() => {
+  const network = useMemo5(() => {
     if (isUndefined5(id)) return;
     return new SimpleXyoNetwork(id);
   }, [
@@ -659,9 +939,10 @@ var useSigner = /* @__PURE__ */ __name((_provider, account) => {
 
 // src/hooks/viewer/useCheckRpc.ts
 import { usePromise as usePromise8 } from "@xylabs/react-promise";
-import { delay as delay2, isDefined as isDefined6, isUndefined as isUndefined6 } from "@xylabs/sdk-js";
-import { AccountBalanceViewerRpcSchemas as AccountBalanceViewerRpcSchemas2, buildJsonRpcProviderLocator as buildJsonRpcProviderLocator2, HttpRpcTransport as HttpRpcTransport2, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2, LocalNetwork, SequenceNetwork, SimpleTransactionViewer as SimpleTransactionViewer2, XyoViewerMoniker } from "@xyo-network/xl1-sdk";
-import { useEffect as useEffect3, useState as useState4 } from "react";
+import { delay as delay2, isDefined as isDefined7, isUndefined as isUndefined6 } from "@xylabs/sdk-js";
+import { basicRemoteViewerLocator as basicRemoteViewerLocator2 } from "@xyo-network/chain-orchestration";
+import { LocalNetwork, SequenceNetwork, XyoViewerMoniker } from "@xyo-network/xl1-sdk";
+import { useEffect as useEffect6, useState as useState7 } from "react";
 var INTERVAL = 5e3;
 var localRpcEndpoint = `${LocalNetwork.url}/rpc`;
 var sequenceRpcEndpoint = `${SequenceNetwork.url}/rpc`;
@@ -670,35 +951,33 @@ var useCheckLocalRpc = /* @__PURE__ */ __name(() => {
   return isLocalProducer;
 }, "useCheckLocalRpc");
 var useCheckSequenceRpc = /* @__PURE__ */ __name(() => {
-  const isLocalProducer = useCheckRpc(sequenceRpcEndpoint);
-  return isLocalProducer;
+  const isSequenceRpc = useCheckRpc(sequenceRpcEndpoint);
+  return isSequenceRpc;
 }, "useCheckSequenceRpc");
 var useCheckRpc = /* @__PURE__ */ __name((endpoint) => {
-  const [isLocalProducer, setIsLocalProducer] = useState4(false);
-  const [error, setError] = useState4();
+  const [isLocalProducer, setIsLocalProducer] = useState7(false);
+  const [error, setError] = useState7();
   const [viewer] = usePromise8(async () => {
     if (isUndefined6(endpoint)) return;
-    const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport2(endpoint, schemas), "transportFactory");
-    const locator = await buildJsonRpcProviderLocator2({
-      transportFactory
+    const locator = await basicRemoteViewerLocator2(endpoint, {
+      rpc: {
+        protocol: "http",
+        url: endpoint
+      }
     });
-    locator.register(SimpleTransactionViewer2.factory(SimpleTransactionViewer2.dependencies, {}));
-    locator.register(JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {
-      transport: await transportFactory(AccountBalanceViewerRpcSchemas2)
-    }));
     const viewer2 = await locator.getInstance(XyoViewerMoniker);
     return viewer2;
   }, [
     endpoint
   ]);
-  useEffect3(() => {
+  useEffect6(() => {
     if (isUndefined6(viewer)) return;
     void (async () => {
       setError(void 0);
       while (!isLocalProducer) {
         try {
           const block = await viewer.currentBlock();
-          setIsLocalProducer(isDefined6(block));
+          setIsLocalProducer(isDefined7(block));
         } catch (err) {
           setError(err);
           setIsLocalProducer(false);
@@ -718,11 +997,11 @@ var useCheckRpc = /* @__PURE__ */ __name((endpoint) => {
 
 // src/hooks/viewer/useHttpRpcViewer.ts
 import { usePromise as usePromise9 } from "@xylabs/react-promise";
-import { isDefined as isDefined7, isString as isString2, isUndefined as isUndefined7 } from "@xylabs/sdk-js";
-import { AccountBalanceViewerRpcSchemas as AccountBalanceViewerRpcSchemas3, buildJsonRpcProviderLocator as buildJsonRpcProviderLocator3, HttpRpcTransport as HttpRpcTransport3, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3, JsonRpcXyoViewer as JsonRpcXyoViewer2, NetworkDataLakeUrls, RestDataLakeViewer, SimpleTransactionViewer as SimpleTransactionViewer3, XyoViewerMoniker as XyoViewerMoniker2, XyoViewerRpcSchemas } from "@xyo-network/xl1-sdk";
+import { isDefined as isDefined8, isString as isString2, isUndefined as isUndefined7 } from "@xylabs/sdk-js";
+import { AccountBalanceViewerRpcSchemas as AccountBalanceViewerRpcSchemas2, buildJsonRpcProviderLocator as buildJsonRpcProviderLocator2, HttpRpcTransport as HttpRpcTransport2, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2, JsonRpcXyoViewer as JsonRpcXyoViewer2, NetworkDataLakeUrls as NetworkDataLakeUrls2, RestDataLakeViewer, SimpleTransactionViewer as SimpleTransactionViewer2, XyoViewerMoniker as XyoViewerMoniker2, XyoViewerRpcSchemas } from "@xyo-network/xl1-sdk";
 
 // src/hooks/viewer/ViewerWithDataLake.ts
-import { isNull as isNull4 } from "@xylabs/sdk-js";
+import { isNull as isNull5 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
 import { addDataLakePayloads, addDataLakePayloadsToPayloads, DataLakeViewerMoniker, JsonRpcXyoViewer } from "@xyo-network/xl1-sdk";
 var ViewerWithDataLake = class extends JsonRpcXyoViewer {
@@ -752,7 +1031,7 @@ var ViewerWithDataLake = class extends JsonRpcXyoViewer {
       await PayloadBuilder2.addHashMeta(transaction[0]),
       await PayloadBuilder2.addHashMeta(transaction[1])
     ] : null;
-    return isNull4(transaction) ? transaction : (await addDataLakePayloads([
+    return isNull5(transaction) ? transaction : (await addDataLakePayloads([
       await PayloadBuilder2.addHashMeta(transaction[0]),
       await PayloadBuilder2.addHashMeta(transaction[1])
     ], this.dataLakeViewer))[0];
@@ -765,11 +1044,11 @@ var buildLocatorParams = /* @__PURE__ */ __name((urlOrNetwork) => {
   let dataLakeViewerParams;
   if (isString2(urlOrNetwork)) {
     const url = urlOrNetwork;
-    transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport3(`${url}/rpc`, schemas), "transportFactory");
+    transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport2(`${url}/rpc`, schemas), "transportFactory");
   } else {
-    transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport3(`${urlOrNetwork.url}/rpc`, schemas), "transportFactory");
+    transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport2(`${urlOrNetwork.url}/rpc`, schemas), "transportFactory");
     dataLakeViewerParams = {
-      endpoint: NetworkDataLakeUrls[urlOrNetwork.id]
+      endpoint: NetworkDataLakeUrls2[urlOrNetwork.id]
     };
   }
   return {
@@ -778,14 +1057,14 @@ var buildLocatorParams = /* @__PURE__ */ __name((urlOrNetwork) => {
   };
 }, "buildLocatorParams");
 var buildLocator = /* @__PURE__ */ __name(async (transportFactory, dataLakeViewerParams) => {
-  const locator = await buildJsonRpcProviderLocator3({
+  const locator = await buildJsonRpcProviderLocator2({
     transportFactory
   });
-  locator.register(JsonRpcAccountBalanceViewer3.factory(JsonRpcAccountBalanceViewer3.dependencies, {
-    transport: await transportFactory(AccountBalanceViewerRpcSchemas3)
+  locator.register(JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {
+    transport: await transportFactory(AccountBalanceViewerRpcSchemas2)
   }));
-  locator.register(SimpleTransactionViewer3.factory(SimpleTransactionViewer3.dependencies, {}));
-  if (isDefined7(dataLakeViewerParams)) {
+  locator.register(SimpleTransactionViewer2.factory(SimpleTransactionViewer2.dependencies, {}));
+  if (isDefined8(dataLakeViewerParams)) {
     locator.register(RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, dataLakeViewerParams));
   }
   locator.register(ViewerWithDataLake.factory(JsonRpcXyoViewer2.dependencies, {
@@ -809,15 +1088,15 @@ var useHttpRpcViewer = /* @__PURE__ */ __name((urlOrNetwork) => {
 
 // src/hooks/viewer/useViewerFromWallet.ts
 import { usePromise as usePromise10 } from "@xylabs/react-promise";
-import { isDefined as isDefined8, isDefinedNotNull as isDefinedNotNull3, isNull as isNull5 } from "@xylabs/sdk-js";
+import { isDefined as isDefined9, isDefinedNotNull as isDefinedNotNull5, isNull as isNull6 } from "@xylabs/sdk-js";
 var useViewerFromWallet = /* @__PURE__ */ __name((networkId, timeout) => {
-  const { gateway, error, isLoading, timedout } = useGateway(networkId, timeout);
+  const { gateway, error, isLoading, timedout } = useGatewayFromWallet(networkId, timeout);
   const result = usePromise10(async () => {
     await Promise.resolve();
-    if (isDefinedNotNull3(error)) return null;
-    if (timedout && isNull5(gateway)) return null;
+    if (isDefinedNotNull5(error)) return null;
+    if (timedout && isNull6(gateway)) return null;
     if (isLoading) return;
-    if (isDefined8(gateway) && isDefined8(networkId)) {
+    if (isDefined9(gateway) && isDefined9(networkId)) {
       const connection = gateway?.connection;
       return connection?.viewer;
     }
@@ -830,16 +1109,16 @@ var useViewerFromWallet = /* @__PURE__ */ __name((networkId, timeout) => {
 }, "useViewerFromWallet");
 
 // src/components/connected/ConnectAccountsStack.tsx
-var DefaultConnectComponent = /* @__PURE__ */ __name((props) => /* @__PURE__ */ React2.createElement(ButtonEx, {
+var DefaultConnectComponent = /* @__PURE__ */ __name((props) => /* @__PURE__ */ React5.createElement(ButtonEx, {
   variant: "contained",
   size: "small",
   ...props
 }), "DefaultConnectComponent");
-var DefaultNoWalletInstalledComponent = /* @__PURE__ */ __name(() => /* @__PURE__ */ React2.createElement(Alert, {
+var DefaultNoWalletInstalledComponent = /* @__PURE__ */ __name(() => /* @__PURE__ */ React5.createElement(Alert, {
   severity: "warning"
-}, /* @__PURE__ */ React2.createElement(AlertTitle, null, "XL1 Wallet Not Found"), /* @__PURE__ */ React2.createElement(Typography2, {
+}, /* @__PURE__ */ React5.createElement(AlertTitle, null, "XL1 Wallet Not Found"), /* @__PURE__ */ React5.createElement(Typography2, {
   gutterBottom: true
-}, "Please ensure that your XL1 Wallet is installed to connect your account."), /* @__PURE__ */ React2.createElement(Button, {
+}, "Please ensure that your XL1 Wallet is installed to connect your account."), /* @__PURE__ */ React5.createElement(Button, {
   sx: {
     display: "flex",
     justifySelf: "end"
@@ -852,136 +1131,50 @@ var DefaultNoWalletInstalledComponent = /* @__PURE__ */ __name(() => /* @__PURE_
 }, "Get XL1 Wallet")), "DefaultNoWalletInstalledComponent");
 var ConnectAccountsStack = /* @__PURE__ */ __name(({ AccountComponent = ConnectedAccount, ConnectComponent = DefaultConnectComponent, NoWalletInstalledComponent = DefaultNoWalletInstalledComponent, onAccountConnected, onCancel, timeout, ...props }) => {
   const { address, connectSigner, error, timedout } = useConnectAccount(void 0, timeout);
-  useEffect4(() => {
-    if (isDefined9(error) && isDefined9(onCancel)) {
+  useEffect7(() => {
+    if (isDefined10(error) && isDefined10(onCancel)) {
       onCancel();
     }
   }, [
     error,
     onCancel
   ]);
-  useEffect4(() => {
-    if (isDefined9(address) && isDefined9(onAccountConnected)) {
+  useEffect7(() => {
+    if (isDefined10(address) && isDefined10(onAccountConnected)) {
       onAccountConnected(address);
     }
   }, [
     address,
     onAccountConnected
   ]);
-  return /* @__PURE__ */ React2.createElement(Stack2, {
+  return /* @__PURE__ */ React5.createElement(Stack2, {
     direction: "row",
     alignItems: "start",
     spacing: 2,
     ...props
-  }, isDefined9(address) ? /* @__PURE__ */ React2.createElement(AccountComponent, {
+  }, isDefined10(address) ? /* @__PURE__ */ React5.createElement(AccountComponent, {
     address
-  }) : null, isUndefined8(address) && !timedout ? /* @__PURE__ */ React2.createElement(ConnectComponent, {
+  }) : null, isUndefined8(address) && !timedout ? /* @__PURE__ */ React5.createElement(ConnectComponent, {
     onClick: /* @__PURE__ */ __name(() => void connectSigner(), "onClick")
-  }, "Connect") : null, isUndefined8(address) && timedout ? /* @__PURE__ */ React2.createElement(NoWalletInstalledComponent, null) : null, /* @__PURE__ */ React2.createElement(ErrorRender, {
+  }, "Connect") : null, isUndefined8(address) && timedout ? /* @__PURE__ */ React5.createElement(NoWalletInstalledComponent, null) : null, /* @__PURE__ */ React5.createElement(ErrorRender2, {
     error,
     scope: "ConnectSigner:error"
   }));
 }, "ConnectAccountsStack");
-
-// src/contexts/current-block/context.ts
-import { createContextEx } from "@xylabs/react-shared";
-var XL1CurrentBlockContext = createContextEx();
-
-// src/contexts/current-block/Provider.tsx
-import React3, { useMemo as useMemo3 } from "react";
-
-// src/contexts/current-block/usePollCurrentBlock.ts
-import { isDefinedNotNull as isDefinedNotNull4, isUndefinedOrNull as isUndefinedOrNull2 } from "@xylabs/sdk-js";
-import { startTransition, useEffect as useEffect5, useState as useState5 } from "react";
-var DEFAULT_POLL_INTERVAL = 1e4;
-var usePollCurrentBlock = /* @__PURE__ */ __name((viewer, interval = DEFAULT_POLL_INTERVAL, pause = false) => {
-  const [currentBlock, setCurrentBlock] = useState5(null);
-  const [error, setError] = useState5();
-  useEffect5(() => {
-    let isMounted = true;
-    const fetchBlock = /* @__PURE__ */ __name(async () => {
-      if (isDefinedNotNull4(viewer)) {
-        try {
-          const block = await viewer.currentBlock();
-          if (isMounted) {
-            startTransition(() => {
-              setCurrentBlock((existingBlock) => {
-                if (isUndefinedOrNull2(existingBlock)) {
-                  return block;
-                }
-                if (isDefinedNotNull4(block) && existingBlock?.[0].block !== block[0].block) {
-                  return block;
-                }
-                return existingBlock;
-              });
-            });
-          }
-        } catch (err) {
-          startTransition(() => {
-            setError(err);
-          });
-        }
-      }
-    }, "fetchBlock");
-    void fetchBlock();
-    const id = setInterval(() => {
-      if (!pause) {
-        void fetchBlock();
-      }
-    }, interval);
-    return () => {
-      isMounted = false;
-      clearInterval(id);
-    };
-  }, [
-    viewer,
-    interval,
-    pause
-  ]);
-  return [
-    currentBlock,
-    error
-  ];
-}, "usePollCurrentBlock");
-
-// src/contexts/current-block/Provider.tsx
-var DEFAULT_POLLING_INTERVAL = 1e4;
-var XL1CurrentBlockProvider = /* @__PURE__ */ __name(({ pollingConfig, viewer, children }) => {
-  const { interval } = useMemo3(() => pollingConfig || {
-    interval: DEFAULT_POLLING_INTERVAL
-  }, [
-    pollingConfig
-  ]);
-  const [currentBlock, currentBlockError] = usePollCurrentBlock(viewer, interval);
-  const value = useMemo3(() => ({
-    block: currentBlock,
-    blockNumber: currentBlock?.[0].block,
-    chain: currentBlock?.[0].chain,
-    error: currentBlockError,
-    pollingConfig,
-    provided: true
-  }), [
-    currentBlock,
-    currentBlockError,
-    pollingConfig
-  ]);
-  return /* @__PURE__ */ React3.createElement(XL1CurrentBlockContext, {
-    value
-  }, children);
-}, "XL1CurrentBlockProvider");
-
-// src/contexts/current-block/use.ts
-import { useContextEx } from "@xylabs/react-shared";
-var useXl1CurrentBlockContext = /* @__PURE__ */ __name((required = true) => useContextEx(XL1CurrentBlockContext, "XL1CurrentBlock", required), "useXl1CurrentBlockContext");
 export {
   ConnectAccountsStack,
   ConnectedAccount,
   DEFAULT_POLLING_INTERVAL,
+  GatewayContext,
+  GatewayProvider,
+  InPageGatewaysContext,
+  InPageGatewaysProvider,
   TransactionConfirmationStatus,
   ViewerWithDataLake,
   XL1CurrentBlockContext,
   XL1CurrentBlockProvider,
   balanceForRange,
+  buildGateway,
   findMinimumBlock,
   formatAccountBalanceHistory,
   getXyoClient,
@@ -993,16 +1186,24 @@ export {
   useCheckRpc,
   useCheckSequenceRpc,
   useClient,
+  useClientFromWallet,
   useConfirmTransactionBase,
   useConnectAccount,
   useCurrentBlock,
+  useCurrentBlockFromGateway,
   useGateway,
+  useGatewayFromWallet,
   useHttpRpcRunner,
   useHttpRpcViewer,
   useNetwork,
+  useNetworkFromGateway,
   usePermissions,
   usePollCurrentBlock,
+  useProvidedGateway,
+  useProvidedInPageGateways,
+  useRunnerFromGateway,
   useSigner,
+  useViewerFromGateway,
   useViewerFromWallet,
   useXl1CurrentBlockContext
 };