@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/wallets/evm/useEVM.js

@@ -1,55 +1,56 @@
-import { useAccount, useConfig, useConnect, useConnectors, useDisconnect, useSwitchAccount } from "wagmi";
+import { useConfig, useConnect, useConnectors, useDisconnect, useSwitchAccount } from "wagmi";
 import { NetworkType } from "../../../Models/Network";
 import { useSettingsState } from "../../../context/settings";
 import KnownInternalNames from "../../knownIds";
 import { resolveWalletConnectorIcon, resolveWalletConnectorIndex } from "../utils/resolveWalletIcon";
 import { evmConnectorNameResolver } from "./KnownEVMConnectors";
-import { useMemo } from "react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
 import { getAccount, getConnections } from '@wagmi/core';
 import { isMobile } from "../../isMobile";
 import convertSvgComponentToBase64 from "../../../components/utils/convertSvgComponentToBase64";
 import { useConnectModal } from "../../../components/Wallet/WalletModal";
-import { explicitInjectedproviderDetected } from "../connectors/getInjectedConnector";
+import { explicitInjectedProviderDetected } from "../connectors/explicitInjectedProviderDetected";
+import sleep from "../utils/sleep";
+import { useEvmConnectors } from "../../../context/evmConnectorsContext";
+import { useActiveEvmAccount } from "../../../components/Wallet/WalletProviders/ActiveEvmAccount";
 const ethereumNames = [KnownInternalNames.Networks.EthereumMainnet, KnownInternalNames.Networks.EthereumSepolia];
 const immutableZKEvm = [KnownInternalNames.Networks.ImmutableZkEVM];
-export default function useEVM({ network }) {
+export default function useEVM() {
     const name = 'EVM';
     const id = 'evm';
     const { networks } = useSettingsState();
-    const asSourceSupportedNetworks = [
+    const asSourceSupportedNetworks = useMemo(() => [
         ...networks.filter(network => network.type === NetworkType.EVM).map(l => l.name),
         KnownInternalNames.Networks.ZksyncMainnet,
         KnownInternalNames.Networks.LoopringGoerli,
         KnownInternalNames.Networks.LoopringMainnet,
         KnownInternalNames.Networks.LoopringSepolia
-    ];
-    const withdrawalSupportedNetworks = [
+    ], [networks]);
+    const withdrawalSupportedNetworks = useMemo(() => [
         ...asSourceSupportedNetworks,
-    ];
-    const autofillSupportedNetworks = [
+    ], [asSourceSupportedNetworks]);
+    const autofillSupportedNetworks = useMemo(() => [
         ...asSourceSupportedNetworks,
         KnownInternalNames.Networks.ImmutableXMainnet,
-        KnownInternalNames.Networks.ImmutableXGoerli,
+        KnownInternalNames.Networks.ImmutableXSepolia,
         KnownInternalNames.Networks.BrineMainnet,
-    ];
+        KnownInternalNames.Networks.HyperliquidMainnet,
+        KnownInternalNames.Networks.HyperliquidTestnet,
+    ], [asSourceSupportedNetworks]);
     const { disconnectAsync } = useDisconnect();
-    const { connectors: activeConnectors, switchAccountAsync } = useSwitchAccount();
-    const activeAccount = useAccount();
+    const { switchAccountAsync } = useSwitchAccount();
+    const { activeConnection, setActiveAddress } = useActiveEvmAccount();
     const allConnectors = useConnectors();
     const config = useConfig();
     const { connectAsync } = useConnect();
-    const { connect, setSelectedConnector } = useConnectModal();
-    const connectWallet = async () => {
-        try {
-            return await connect(provider);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    };
-    const disconnectWallet = async (connectorName) => {
+    const pendingResolve = useRef();
+    const pendingId = useRef();
+    const { setSelectedConnector } = useConnectModal();
+    const { walletConnectConnectors, addWalletConnectWallet } = useEvmConnectors();
+    const disconnectWallet = useCallback(async (connectorName) => {
         try {
-            const connector = activeConnectors.find(w => w.name.toLowerCase() === connectorName.toLowerCase());
+            const connections = getConnections(config);
+            const connector = connections.find(c => c.connector.name.toLowerCase() === connectorName.toLowerCase())?.connector;
             await disconnectAsync({
                 connector: connector
             });
@@ -57,19 +58,54 @@ export default function useEVM({ network }) {
         catch (e) {
             console.log(e);
         }
-    };
-    const disconnectWallets = () => {
+    }, [config, disconnectAsync]);
+    const disconnectWallets = useCallback(() => {
         try {
-            activeConnectors.forEach(async (connector) => {
-                disconnectWallet(connector.name);
+            const connections = getConnections(config);
+            connections.forEach(async (connection) => {
+                disconnectWallet(connection.connector.name);
             });
         }
         catch (e) {
             console.log(e);
         }
-    };
-    const connectConnector = async ({ connector }) => {
+    }, [config, disconnectWallet]);
+    const availableFeaturedWalletsForConnect = useMemo(() => {
+        const activeBrowserWallet = explicitInjectedProviderDetected() && allConnectors.filter(c => c.id !== "com.immutable.passport" && c.type === "injected").length === 1;
+        const filterConnectors = wallet => ((wallet.id === "injected" ? activeBrowserWallet : true));
+        return dedupePreferInjected(allConnectors.filter(filterConnectors))
+            .map(w => {
+            const isWalletConnectSupported = walletConnectConnectors.some(w2 => w2.name.toLowerCase().includes(w.name.toLowerCase()) && (w2.mobile.universal || w2.mobile.native || w2?.desktop?.native || w2?.desktop?.universal)) || w.name === "WalletConnect";
+            return {
+                ...w,
+                order: resolveWalletConnectorIndex(w.id),
+                type: (w.type == 'injected' && w.id !== 'com.immutable.passport') ? w.type : "other",
+                isMobileSupported: isWalletConnectSupported
+            };
+        });
+    }, [allConnectors, walletConnectConnectors]);
+    const connectWallet = useCallback(async (props) => {
         try {
+            const internalConnector = props?.connector;
+            if (!internalConnector)
+                return;
+            let connector = availableFeaturedWalletsForConnect.find(w => w.id === internalConnector.id);
+            if (!connector) {
+                const walletConnectConnector = walletConnectConnectors.find(w => w.id === internalConnector.id);
+                if (!walletConnectConnector)
+                    throw new Error("Connector not found");
+                await addWalletConnectWallet(walletConnectConnector);
+                connector = await new Promise((res, rej) => {
+                    pendingId.current = walletConnectConnector.id;
+                    pendingResolve.current = res;
+                    setTimeout(() => {
+                        if (pendingResolve.current) {
+                            pendingResolve.current = undefined;
+                            rej(new Error("Timed out waiting for new connector"));
+                        }
+                    }, 4000);
+                });
+            }
             const Icon = connector.icon || resolveWalletConnectorIcon({ connector: evmConnectorNameResolver(connector) });
             const base64Icon = typeof Icon == 'string' ? Icon : convertSvgComponentToBase64(Icon);
             setSelectedConnector({ ...connector, icon: base64Icon });
@@ -84,7 +120,7 @@ export default function useEVM({ network }) {
                     });
                 }
             }
-            else if (connector.type !== 'injected' && connector.id !== "coinbaseWalletSDK") {
+            else if (connector.type !== 'injected' && connector.isMobileSupported && connector.id !== "coinbaseWalletSDK") {
                 setSelectedConnector({ ...connector, qr: { state: 'loading', value: undefined } });
                 getWalletConnectUri(connector, connector?.resolveURI, (uri) => {
                     setSelectedConnector({ ...connector, icon: base64Icon, qr: { state: 'fetched', value: uri } });
@@ -93,7 +129,16 @@ export default function useEVM({ network }) {
             await connectAsync({ connector });
             const activeAccount = await attemptGetAccount(config);
             const connections = getConnections(config);
-            const connection = connections.find(c => c.connector.id === connector?.id);
+            let connection = connections.find(c => c.connector.id === connector?.id);
+            if (!connection) {
+                const address = await connector.getAccounts();
+                const chainId = await connector.getChainId();
+                connection = {
+                    accounts: address,
+                    chainId: Number(chainId),
+                    connector
+                };
+            }
             const wallet = ResolveWallet({
                 activeConnection: (activeAccount.connector && activeAccount.address) ? {
                     id: activeAccount.connector.id,
@@ -102,7 +147,6 @@ export default function useEVM({ network }) {
                 connection,
                 discconnect: disconnectWallet,
                 networks,
-                network,
                 supportedNetworks: {
                     asSource: asSourceSupportedNetworks,
                     autofill: autofillSupportedNetworks,
@@ -122,20 +166,19 @@ export default function useEVM({ network }) {
                 throw new Error(e.message || e);
             }
         }
-    };
+    }, [availableFeaturedWalletsForConnect, disconnectAsync, networks, asSourceSupportedNetworks, autofillSupportedNetworks, withdrawalSupportedNetworks, name, config]);
+    const connectedWalletsKey = [...config.state.connections.keys()].join('-');
     const resolvedConnectors = useMemo(() => {
         const connections = getConnections(config);
-        return activeConnectors.map((w) => {
-            const connection = connections.find(c => c.connector.id === w.id);
+        return connections.map((connection) => {
             const wallet = ResolveWallet({
-                activeConnection: (activeAccount.connector && activeAccount.address) ? {
-                    id: activeAccount.connector.id,
-                    address: activeAccount.address
+                activeConnection: (activeConnection?.id && activeConnection.address) ? {
+                    id: activeConnection.id,
+                    address: activeConnection.address
                 } : undefined,
                 connection,
                 discconnect: disconnectWallet,
                 networks,
-                network,
                 supportedNetworks: {
                     asSource: asSourceSupportedNetworks,
                     autofill: autofillSupportedNetworks,
@@ -145,8 +188,8 @@ export default function useEVM({ network }) {
             });
             return wallet;
         }).filter(w => w !== undefined);
-    }, [activeAccount, activeConnectors, config, network]);
-    const switchAccount = async (wallet, address) => {
+    }, [activeConnection, config, connectedWalletsKey]);
+    const switchAccount = useCallback(async (wallet, address) => {
         const connector = getConnections(config).find(c => c.connector.name === wallet.id)?.connector;
         if (!connector)
             throw new Error("Connector not found");
@@ -154,36 +197,49 @@ export default function useEVM({ network }) {
         const account = accounts.find(a => a.toLowerCase() === address.toLowerCase());
         if (!account)
             throw new Error("Account not found");
+        setActiveAddress(account);
+    }, [config, switchAccountAsync]);
+    const switchChain = async (wallet, chainId) => {
+        const connector = getConnections(config).find(c => c.connector.name === wallet.id)?.connector;
+        if (!connector)
+            throw new Error("Connector not found");
+        if (connector?.switchChain) {
+            await connector.switchChain({ chainId: Number(chainId) });
+        }
+        else {
+            throw new Error("Switch chain method is not available on the connector");
+        }
     };
-    const activeBrowserWallet = explicitInjectedproviderDetected() && allConnectors.filter(c => c.id !== "com.immutable.passport" && c.type === "injected").length === 1;
-    const filterConnectors = wallet => !isNotAvailable(wallet, network) && ((wallet.id === "injected" ? activeBrowserWallet : true));
-    // const fetchedWallets = useMemo(() => Object.values(walletsData.listings), [])
-    { /* //TODO: refactor ordering */ }
-    const availableWalletsForConnect = allConnectors.filter(filterConnectors)
-        .map(w => {
-        // const isMobileSupported = fetchedWallets.some(w2 => w2.name.toLowerCase() === w.name.toLowerCase() && w2.mobile.native)
+    const activeWallet = useMemo(() => resolvedConnectors.find(w => w.isActive), [resolvedConnectors]);
+    const providerIcon = useMemo(() => networks.find(n => ethereumNames.some(name => name === n.name))?.logo, [networks]);
+    useEffect(() => {
+        if (!pendingResolve.current)
+            return;
+        const found = availableFeaturedWalletsForConnect.find(c => c.id === pendingId.current);
+        if (found) {
+            pendingResolve.current(found);
+            pendingResolve.current = undefined;
+        }
+    }, [availableFeaturedWalletsForConnect, pendingId.current, pendingResolve.current]);
+    const provider = useMemo(() => {
         return {
-            ...w,
-            order: resolveWalletConnectorIndex(w.id),
-            type: (w.type == 'injected' && w.id !== 'com.immutable.passport') ? w.type : "other",
-            // isMobileSupported
+            connectWallet,
+            disconnectWallets,
+            switchAccount,
+            switchChain,
+            isNotAvailableCondition: isNotAvailable,
+            connectedWallets: resolvedConnectors,
+            activeWallet,
+            autofillSupportedNetworks,
+            withdrawalSupportedNetworks,
+            asSourceSupportedNetworks,
+            availableWalletsForConnect: availableFeaturedWalletsForConnect,
+            availableHiddenWalletsForConnect: walletConnectConnectors,
+            name,
+            id,
+            providerIcon
         };
-    });
-    const provider = {
-        connectWallet,
-        connectConnector,
-        disconnectWallets,
-        switchAccount,
-        connectedWallets: resolvedConnectors,
-        activeWallet: resolvedConnectors.find(w => w.isActive),
-        autofillSupportedNetworks,
-        withdrawalSupportedNetworks,
-        asSourceSupportedNetworks,
-        availableWalletsForConnect: availableWalletsForConnect,
-        name,
-        id,
-        providerIcon: networks.find(n => ethereumNames.some(name => name === n.name))?.logo
-    };
+    }, [connectWallet, disconnectWallets, switchAccount, resolvedConnectors, availableFeaturedWalletsForConnect, walletConnectConnectors, autofillSupportedNetworks, withdrawalSupportedNetworks, asSourceSupportedNetworks, name, id, networks]);
     return provider;
 }
 const getWalletConnectUri = async (connector, uriConverter = (uri) => uri, useCallback) => {
@@ -203,30 +259,30 @@ const isNotAvailable = (connector, network) => {
         return false;
     if (!connector)
         return true;
-    return resolveSupportedNetworks([network.name], connector.id).length === 0;
+    return resolveSupportedNetworks([network], connector).length === 0;
 };
 const ResolveWallet = (props) => {
-    const { activeConnection, connection, networks, discconnect, network, supportedNetworks, providerName } = props;
-    const accountIsActive = activeConnection?.id === connection?.connector.id;
+    const { activeConnection, connection, networks, discconnect, supportedNetworks, providerName } = props;
+    const walletIsActive = activeConnection?.id === connection?.connector.id;
     const addresses = connection?.accounts;
     const activeAddress = activeConnection?.address;
     const connector = connection?.connector;
     if (!connector)
         return undefined;
-    const address = accountIsActive ? activeAddress : addresses?.[0];
+    const address = walletIsActive ? activeAddress : addresses?.[0];
     if (!address)
         return undefined;
     const walletname = `${connector?.name} ${connector.id === "com.immutable.passport" ? "" : " - EVM"}`;
     const wallet = {
         id: connector.name,
-        isActive: accountIsActive,
+        internalId: connector.id,
+        isActive: walletIsActive,
         address,
         addresses: addresses || [address],
         displayName: walletname,
         providerName,
         icon: resolveWalletConnectorIcon({ connector: evmConnectorNameResolver(connector), address, iconUrl: connector.icon }),
         disconnect: () => discconnect(connector.name),
-        isNotAvailable: isNotAvailable(connector, network),
         asSourceSupportedNetworks: resolveSupportedNetworks(supportedNetworks.asSource, connector.id),
         autofillSupportedNetworks: resolveSupportedNetworks(supportedNetworks.autofill, connector.id),
         withdrawalSupportedNetworks: resolveSupportedNetworks(supportedNetworks.withdrawal, connector.id),
@@ -254,9 +310,18 @@ const resolveSupportedNetworks = (supportedNetworks, connectorId) => {
                 KnownInternalNames.Networks.RoninMainnet,
                 KnownInternalNames.Networks.EthereumMainnet,
                 KnownInternalNames.Networks.PolygonMainnet,
+                KnownInternalNames.Networks.BaseMainnet,
                 KnownInternalNames.Networks.BNBChainMainnet,
                 KnownInternalNames.Networks.ArbitrumMainnet
             ]
+        },
+        {
+            id: "app.phantom",
+            supportedNetworks: [
+                KnownInternalNames.Networks.EthereumMainnet,
+                KnownInternalNames.Networks.BaseMainnet,
+                KnownInternalNames.Networks.PolygonMainnet,
+            ]
         }
     ];
     const specificNetworks = specificNetworksConnectors.find(c => c.id === connectorId);
@@ -268,14 +333,26 @@ const resolveSupportedNetworks = (supportedNetworks, connectorId) => {
 };
 async function attemptGetAccount(config, maxAttempts = 5) {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        const account = await getAccount(config);
+        const account = getAccount(config);
         if (account.address) {
             return account;
         }
         await sleep(500);
     }
-    return await getAccount(config);
+    return getAccount(config);
 }
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+function dedupePreferInjected(arr) {
+    // Helper to strip off any prefix up to the last dot
+    const getBaseId = (id) => id.includes('.') ? id.split('.').pop() : id;
+    // Group items by normalized base‐id
+    const groups = arr.reduce((acc, obj) => {
+        const key = getBaseId(obj.name);
+        (acc[key] = acc[key] || []).push(obj);
+        return acc;
+    }, {});
+    // Within each group, if any are injected prefer them, otherwise keep all
+    return Object.values(groups).flatMap(group => {
+        const injected = group.filter(o => o.type === 'injected');
+        return injected.length > 0 ? injected : group;
+    });
 }

package/dist/lib/wallets/fuel/Bako.d.ts

@@ -0,0 +1,15 @@
+export declare class BAKO_STATE {
+    static state: {
+        last_req?: Date;
+        data: boolean;
+        req_count: number;
+        period_start?: Date;
+    };
+    static period_durtion: number;
+}
+export declare class BaskoRequestAPI {
+    baseUrl: string;
+    constructor(baseUrl: string);
+    get(pathname: string): Promise<any>;
+    delete(pathname: string): Promise<void>;
+}

package/dist/lib/wallets/fuel/Bako.js

@@ -1,34 +1,29 @@
-// import { urlJoin } from "@fuel-ts/account";
-// export class BAKO_STATE {
-//     static state: { last_req?: Date, data: boolean, req_count: number, period_start?: Date } = { data: false, req_count: 0 }
-//     static period_durtion: number = 10_000
-// }
-// export class BaskoRequestAPI {
-//     baseUrl: string;
-//     constructor(baseUrl: string) {
-//         this.baseUrl = baseUrl;
-//     }
-//     async get(pathname: string) {
-//         if (!pathname.includes('/state')) {
-//             const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) =>
-//                 res.json(),
-//             );
-//             return data;
-//         }
-//         const period_elapsed = BAKO_STATE.state?.period_start && new Date().getTime() - BAKO_STATE.state?.period_start?.getTime() > BAKO_STATE.period_durtion;
-//         const skip = BAKO_STATE.state?.last_req && new Date().getTime() - BAKO_STATE.state?.last_req?.getTime() < 1000 * 60 * 2 && period_elapsed;
-//         if (skip)
-//             return BAKO_STATE.state?.data;
-//         const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) =>
-//             res.json(),
-//         );
-//         const count = BAKO_STATE.state?.req_count || 0;
-//         BAKO_STATE.state = { last_req: new Date(), data, req_count: count + 1, period_start: period_elapsed ? new Date() : BAKO_STATE.state?.period_start || new Date() };
-//         return data;
-//     }
-//     async delete(pathname: string) {
-//         await fetch(urlJoin(this.baseUrl, pathname), {
-//             method: 'DELETE',
-//         });
-//     }
-// }
+import { urlJoin } from "@fuel-ts/account";
+export class BAKO_STATE {
+}
+BAKO_STATE.state = { data: false, req_count: 0 };
+BAKO_STATE.period_durtion = 10000;
+export class BaskoRequestAPI {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async get(pathname) {
+        if (!pathname.includes('/state')) {
+            const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+            return data;
+        }
+        const period_elapsed = BAKO_STATE.state?.period_start && new Date().getTime() - BAKO_STATE.state?.period_start?.getTime() > BAKO_STATE.period_durtion;
+        const skip = BAKO_STATE.state?.last_req && new Date().getTime() - BAKO_STATE.state?.last_req?.getTime() < 1000 * 60 * 2 && period_elapsed;
+        if (skip)
+            return BAKO_STATE.state?.data;
+        const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+        const count = BAKO_STATE.state?.req_count || 0;
+        BAKO_STATE.state = { last_req: new Date(), data, req_count: count + 1, period_start: period_elapsed ? new Date() : BAKO_STATE.state?.period_start || new Date() };
+        return data;
+    }
+    async delete(pathname) {
+        await fetch(urlJoin(this.baseUrl, pathname), {
+            method: 'DELETE',
+        });
+    }
+}

package/dist/lib/wallets/fuel/Basko.d.ts

@@ -0,0 +1,15 @@
+export declare class BAKO_STATE {
+    static state: {
+        last_req?: Date;
+        data: boolean;
+        req_count: number;
+        period_start?: Date;
+    };
+    static period_durtion: number;
+}
+export declare class BaskoRequestAPI {
+    baseUrl: string;
+    constructor(baseUrl: string);
+    get(pathname: string): Promise<any>;
+    delete(pathname: string): Promise<void>;
+}

package/dist/lib/wallets/fuel/Basko.js

@@ -1,34 +1,29 @@
-// import { urlJoin } from "@fuel-ts/account";
-// export class BAKO_STATE {
-//     static state: { last_req?: Date, data: boolean, req_count: number, period_start?: Date } = { data: false, req_count: 0 }
-//     static period_durtion: number = 10_000
-// }
-// export class BaskoRequestAPI {
-//     baseUrl: string;
-//     constructor(baseUrl: string) {
-//         this.baseUrl = baseUrl;
-//     }
-//     async get(pathname: string) {
-//         if (!pathname.includes('/state')) {
-//             const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) =>
-//                 res.json(),
-//             );
-//             return data;
-//         }
-//         const period_elapsed = BAKO_STATE.state?.period_start && new Date().getTime() - BAKO_STATE.state?.period_start?.getTime() > BAKO_STATE.period_durtion;
-//         const skip = BAKO_STATE.state?.last_req && new Date().getTime() - BAKO_STATE.state?.last_req?.getTime() < 1000 * 60 * 2 && period_elapsed;
-//         if (skip)
-//             return BAKO_STATE.state?.data;
-//         const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) =>
-//             res.json(),
-//         );
-//         const count = BAKO_STATE.state?.req_count || 0;
-//         BAKO_STATE.state = { last_req: new Date(), data, req_count: count + 1, period_start: period_elapsed ? new Date() : BAKO_STATE.state?.period_start || new Date() };
-//         return data;
-//     }
-//     async delete(pathname: string) {
-//         await fetch(urlJoin(this.baseUrl, pathname), {
-//             method: 'DELETE',
-//         });
-//     }
-// }
+import { urlJoin } from "@fuel-ts/account";
+export class BAKO_STATE {
+}
+BAKO_STATE.state = { data: false, req_count: 0 };
+BAKO_STATE.period_durtion = 10000;
+export class BaskoRequestAPI {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async get(pathname) {
+        if (!pathname.includes('/state')) {
+            const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+            return data;
+        }
+        const period_elapsed = BAKO_STATE.state?.period_start && new Date().getTime() - BAKO_STATE.state?.period_start?.getTime() > BAKO_STATE.period_durtion;
+        const skip = BAKO_STATE.state?.last_req && new Date().getTime() - BAKO_STATE.state?.last_req?.getTime() < 1000 * 60 * 2 && period_elapsed;
+        if (skip)
+            return BAKO_STATE.state?.data;
+        const data = await fetch(urlJoin(this.baseUrl, pathname)).then((res) => res.json());
+        const count = BAKO_STATE.state?.req_count || 0;
+        BAKO_STATE.state = { last_req: new Date(), data, req_count: count + 1, period_start: period_elapsed ? new Date() : BAKO_STATE.state?.period_start || new Date() };
+        return data;
+    }
+    async delete(pathname) {
+        await fetch(urlJoin(this.baseUrl, pathname), {
+            method: 'DELETE',
+        });
+    }
+}

package/dist/lib/wallets/fuel/useFuel.d.ts

@@ -0,0 +1,2 @@
+import { WalletProvider } from "../../../Models/WalletProvider";
+export default function useFuel(): WalletProvider;