@layerswap/wallet-fuel 1.7.0 → 2.0.0

package/dist/esm/constants.js

@@ -1,4 +1,4 @@
-import { KnownInternalNames } from "@layerswap/widget/internal";
+import { KnownInternalNames } from "@layerswap/utils";
 export const name = 'Fuel';
 export const id = 'fuel';
 export const commonSupportedNetworks = [

package/dist/esm/fuelBalanceProvider.js

@@ -1,5 +1,5 @@
-import { retryWithExponentialBackoff, fetchWithTimeout, KnownInternalNames, formatUnits } from "@layerswap/widget/internal";
-import { BalanceProvider } from "@layerswap/widget/types";
+import { retryWithExponentialBackoff, fetchWithTimeout, KnownInternalNames, formatUnits } from "@layerswap/utils";
+import { BalanceProvider } from "@layerswap/widget-types";
 export class FuelBalanceProvider extends BalanceProvider {
     constructor() {
         super(...arguments);

package/dist/esm/fuelGasProvider.js

@@ -1,5 +1,6 @@
 import WatchdogAbi from './jsons/FUELWATCHDOG.json';
-import { ErrorHandler, KnownInternalNames, formatUnits } from "@layerswap/widget/internal";
+import { KnownInternalNames, formatUnits } from "@layerswap/utils";
+import { ErrorHandler } from "@layerswap/widget-types";
 export class FuelGasProvider {
     supportsNetwork(network) {
         return (KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name));

package/dist/esm/index.js

@@ -1,16 +1,24 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 import { FuelBalanceProvider } from "./fuelBalanceProvider";
 import { FuelGasProvider } from "./fuelGasProvider";
-import FuelProviderWrapper from "./FuelProvider";
-import useFuelConnection from "./useFuelConnection";
-import React from "react";
-import { useFuelTransfer } from "./transferProvider/useFuelTransfer";
+import { createFuelTransfer } from "./transferProvider/createFuelTransfer";
+import { createFuelConnection } from "./service/createFuelConnection";
+import { initFuelProvider } from "./init";
+import { id } from "./constants";
+// The literal id in the return type lets `defineWalletDescriptor` in
+// `@layerswap/wallets` verify it matches the descriptor id at compile time.
 export function createFuelProvider(config = {}) {
-    const { customHook, balanceProviders, gasProviders, transferProviders } = config;
-    const WrapperComponent = ({ children }) => {
-        return (_jsx(FuelProviderWrapper, { children: children }));
+    const { customConnection, balanceProviders, gasProviders, transferProviders, } = config;
+    const init = (_ctx) => {
+        initFuelProvider();
+        // No-op disposer; init is idempotent across remounts.
+    };
+    const createConnection = (props) => {
+        initFuelProvider();
+        if (customConnection) {
+            return customConnection(props);
+        }
+        return createFuelConnection(props);
     };
-    const walletConnectionProvider = customHook || useFuelConnection;
     const defaultBalanceProviders = [new FuelBalanceProvider()];
     const finalBalanceProviders = balanceProviders !== undefined
         ? (Array.isArray(balanceProviders) ? balanceProviders : [balanceProviders])
@@ -19,27 +27,19 @@ export function createFuelProvider(config = {}) {
     const finalGasProviders = gasProviders !== undefined
         ? (Array.isArray(gasProviders) ? gasProviders : [gasProviders])
         : defaultGasProviders;
-    const defaultTransferProviders = [useFuelTransfer];
+    const defaultTransferProviders = [createFuelTransfer];
     const finalTransferProviders = transferProviders !== undefined
         ? (Array.isArray(transferProviders) ? transferProviders : [transferProviders])
         : defaultTransferProviders;
     return {
-        id: "fuel",
-        wrapper: WrapperComponent,
-        walletConnectionProvider,
+        id,
+        init,
+        createConnection,
         gasProvider: finalGasProviders,
         balanceProvider: finalBalanceProviders,
         transferProvider: finalTransferProviders,
     };
 }
-/**
- * @deprecated Use createFuelProvider() instead. This export will be removed in a future version.
- */
-export const FuelProvider = {
-    id: "fuel",
-    wrapper: FuelProviderWrapper,
-    walletConnectionProvider: useFuelConnection,
-    gasProvider: [new FuelGasProvider()],
-    balanceProvider: [new FuelBalanceProvider()],
-    transferProvider: [useFuelTransfer],
-};
+export { createFuelConnection } from "./service/createFuelConnection";
+export { useFuelStore } from "./service/fuelStore";
+export { getFuelInstance, hasFuelInstance } from "./service/getFuel";

package/dist/esm/init.js

@@ -0,0 +1,38 @@
+import { Fuel } from '@fuel-ts/account';
+import { BakoSafeConnector } from './connectors/bako-safe';
+import { BakoRequestAPI } from './connectors/bako-safe/Bako';
+import { FuelWalletConnector } from './connectors/fuel-wallet';
+import { FueletWalletConnector } from './connectors/fuelet-wallet';
+import { hasFuelInstance, setFuelInstance } from './service/getFuel';
+import { attachFuelSync } from './service/syncFuel';
+const HOST_URL = 'https://api.bako.global';
+let _initialized = false;
+/**
+ * One-shot initialization of the Fuel SDK + store sync.
+ * Safe to call multiple times — subsequent calls are no-ops.
+ */
+export function initFuelProvider() {
+    if (_initialized)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    if (hasFuelInstance()) {
+        _initialized = true;
+        return;
+    }
+    const fuel = new Fuel({
+        connectors: [
+            new FuelWalletConnector(),
+            new BakoSafeConnector({ api: new BakoRequestAPI(HOST_URL) }),
+            new FueletWalletConnector(),
+        ],
+    });
+    setFuelInstance(fuel);
+    attachFuelSync(fuel);
+    _initialized = true;
+}
+/** Visible for tests. Resets the singleton init so a fresh init can run. */
+export function _resetFuelInit() {
+    _initialized = false;
+    setFuelInstance(null);
+}

package/dist/esm/service/FuelConnectionService.js

@@ -0,0 +1,232 @@
+import { sleep } from "@layerswap/utils";
+import { Address } from '@fuel-ts/address';
+import { name as PROVIDER_NAME, id as PROVIDER_ID } from '../constants';
+import { BAKO_STATE } from '../connectors/bako-safe/Bako';
+import { resolveFuelWalletConnectorIcon } from '../utils';
+import { useFuelStore } from './fuelStore';
+export class FuelConnectionService {
+    constructor() {
+        this._networks = [];
+        this._networksKey = '';
+        // `connectWallet` mutates the module-global `BAKO_STATE.{state.last_req,
+        // period_durtion}` while connecting. Rapid double-clicks or a retry firing
+        // while a connect is still in flight would interleave those writes. Chain
+        // connects through this promise so they run one-at-a-time.
+        this._connectQueue = Promise.resolve();
+    }
+    setNetworks(networks, networkAdapter) {
+        const key = networks.map(network => networkAdapter.getId(network)).join('|');
+        if (this._networksKey === key)
+            return;
+        this._networks = networks;
+        this._networkAdapter = networkAdapter;
+        this._networksKey = key;
+    }
+    addWallet(wallet) {
+        useFuelStore.getState().connectWallet(wallet);
+    }
+    removeWallet(connectorName) {
+        useFuelStore.getState().disconnectWallet(connectorName);
+    }
+    getConnectedWallets() {
+        return useFuelStore.getState().connectedWallets;
+    }
+    getSupportedNetworks() {
+        return this._networks
+            .filter(network => this._networkAdapter?.isFuelNetwork(network))
+            .map(network => this._networkAdapter?.getId(network))
+            .filter((id) => !!id);
+    }
+    getNetworkIcon() {
+        const network = this._networks.find(item => this._networkAdapter?.isFuelNetwork(item));
+        return network && this._networkAdapter ? this._networkAdapter.getIcon(network) : undefined;
+    }
+    // Connector icons come either as a URL string or as a { dark, light } pair
+    // of raw SVG markup; the latter is wrapped as a base64 data URL unless it
+    // already is one. Shared by getAvailableConnectors and resolveFuelWallet.
+    resolveConnectorImageIcon(image) {
+        if (!image)
+            return undefined;
+        if (typeof image === 'string')
+            return image;
+        return image.dark.startsWith('data:')
+            ? image.dark
+            : `data:image/svg+xml;base64,${btoa(image.dark)}`;
+    }
+    getAvailableConnectors() {
+        const connectors = useFuelStore.getState().connectors;
+        return connectors.map(c => {
+            const icon = this.resolveConnectorImageIcon(c.metadata.image);
+            const isInstalled = c.installed && !c['dAppWindow'];
+            const isLoadable = c.metadata?.install?.action !== 'Install';
+            return {
+                name: c.name,
+                id: c.name,
+                icon,
+                type: isInstalled ? 'injected' : 'other',
+                installUrl: c.metadata.install.link,
+                extensionNotFound: !c.installed,
+                isLoadable,
+                providerName: PROVIDER_NAME,
+            };
+        });
+    }
+    async resolveFuelWallet(connector, address, addresses) {
+        const network = await connector.currentNetwork();
+        const chainId = network.chainId ?? (network.url.toLowerCase().includes('testnet') ? 0 : 9889);
+        const icon = this.resolveConnectorImageIcon(connector.metadata.image);
+        return {
+            id: connector.name,
+            address,
+            addresses,
+            isActive: true,
+            chainId,
+            disconnect: () => this.disconnectWallet(connector.name),
+            displayName: `${connector.name} - Fuel`,
+            providerName: PROVIDER_NAME,
+            icon: resolveFuelWalletConnectorIcon({ connector: connector.name, address, iconUrl: icon }),
+            autofillSupportedNetworks: this.getSupportedNetworks(),
+            withdrawalSupportedNetworks: this.getSupportedNetworks(),
+            asSourceSupportedNetworks: this.getSupportedNetworks(),
+            networkIcon: this.getNetworkIcon(),
+        };
+    }
+    connectWallet({ connector }) {
+        // Serialize against any in-flight connect (see `_connectQueue`). The
+        // `.then(run, run)` runs `run` whether the prior connect resolved or
+        // rejected, so one failure doesn't wedge the queue.
+        const run = () => this.doConnectWallet({ connector });
+        const result = this._connectQueue.then(run, run);
+        this._connectQueue = result.catch(() => { });
+        return result;
+    }
+    async doConnectWallet({ connector }) {
+        const attemptConnection = async (isRetry = false) => {
+            try {
+                const fuelConnector = useFuelStore.getState().connectors.find(w => w.name === connector.name);
+                BAKO_STATE.state.last_req = undefined;
+                BAKO_STATE.period_durtion = 120000;
+                await fuelConnector?.connect();
+                const addresses = (await fuelConnector?.accounts())?.map(a => new Address(a).toB256());
+                if (!addresses || !fuelConnector)
+                    return undefined;
+                const result = await this.resolveFuelWallet(fuelConnector, addresses[0], addresses);
+                this.addWallet(result);
+                await this.switchAccount(result);
+                return result;
+            }
+            catch (e) {
+                if (connector.name === 'Bako Safe' && e === false && !isRetry) {
+                    console.log('Bako Safe connection failed with false, retrying once...');
+                    await sleep(1000);
+                    return await attemptConnection(true);
+                }
+                throw e instanceof Error ? e : new Error(typeof e === 'string' ? e : JSON.stringify(e));
+            }
+        };
+        return attemptConnection();
+    }
+    async disconnectWallet(connectorName) {
+        try {
+            const fuelConnector = useFuelStore.getState().connectors.find(c => c.name === connectorName);
+            if (!fuelConnector)
+                throw new Error('Connector not found');
+            await fuelConnector.disconnect();
+        }
+        catch (e) {
+            // Disconnect is best-effort — log but do not rethrow; the wallet is
+            // removed from the store in `finally` regardless.
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[Fuel] Failed to disconnect ${connectorName}: ${msg}`);
+        }
+        finally {
+            this.removeWallet(connectorName);
+        }
+    }
+    async disconnectWallets() {
+        try {
+            BAKO_STATE.state.last_req = undefined;
+            BAKO_STATE.period_durtion = 10000;
+            const connectors = useFuelStore.getState().connectors;
+            for (const connector of connectors.filter(c => c.connected)) {
+                await connector.disconnect();
+                this.removeWallet();
+            }
+        }
+        catch (e) {
+            // Best-effort bulk disconnect — log but do not rethrow.
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[Fuel] Failed to disconnect wallets: ${msg}`);
+        }
+    }
+    async switchAccount(wallet) {
+        try {
+            const fuel = useFuelStore.getState().fuel;
+            if (!fuel)
+                throw new Error('Fuel instance not available');
+            const res = await fuel.selectConnector(wallet.id);
+            if (!res)
+                throw new Error('Could not switch account');
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[Fuel] Failed to switch account to ${wallet.id}: ${msg}`);
+        }
+    }
+    async switchChain(connector, chainId) {
+        try {
+            const fuelConnector = useFuelStore.getState().connectors.find(c => c.name === connector.id);
+            if (!fuelConnector)
+                throw new Error('Connector not found');
+            const res = await fuelConnector.selectNetwork({ chainId: Number(chainId) });
+            if (!res)
+                throw new Error('Could not switch chain');
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[Fuel] Failed to switch chain to ${chainId}: ${msg}`);
+        }
+    }
+    async resolveConnectedWallets() {
+        const connectors = useFuelStore.getState().connectors.filter(c => c.connected);
+        const wallets = [];
+        for (const connector of connectors) {
+            try {
+                const addresses = (await connector.accounts()).map(a => Address.fromAddressOrString(a).toB256());
+                if (connector.connected && addresses.length > 0) {
+                    const w = await this.resolveFuelWallet(connector, addresses[0], addresses);
+                    wallets.push(w);
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`[Fuel] Failed to resolve connected wallet for ${connector.name}: ${msg}`);
+            }
+        }
+        return wallets;
+    }
+    async syncConnectedWallets() {
+        const wallets = await this.resolveConnectedWallets();
+        for (const wallet of wallets) {
+            this.addWallet(wallet);
+        }
+    }
+    buildProvider() {
+        const connectedWallets = this.getConnectedWallets();
+        return {
+            connectWallet: this.connectWallet.bind(this),
+            disconnectWallets: this.disconnectWallets.bind(this),
+            switchAccount: this.switchAccount.bind(this),
+            switchChain: this.switchChain.bind(this),
+            availableConnectors: this.getAvailableConnectors(),
+            autofillSupportedNetworks: this.getSupportedNetworks(),
+            withdrawalSupportedNetworks: this.getSupportedNetworks(),
+            asSourceSupportedNetworks: this.getSupportedNetworks(),
+            activeWallet: connectedWallets[0],
+            connectedWallets,
+            name: PROVIDER_NAME,
+            id: PROVIDER_ID,
+            ready: useFuelStore.getState().ready,
+        };
+    }
+}

package/dist/esm/service/createFuelConnection.js

@@ -0,0 +1,45 @@
+import { createMemoizedConnectionStore } from "@layerswap/wallet-core";
+import { createFuelTransfer } from '../transferProvider/createFuelTransfer';
+import { FuelConnectionService } from './FuelConnectionService';
+import { registerFuelWalletSynchronizer } from './syncFuel';
+import { useFuelStore } from './fuelStore';
+/**
+ * Vanilla external-store factory for the Fuel wallet connection. Replaces the
+ * old `useFuelConnection` hook.
+ */
+export function createFuelConnection(initialProps, options = {}) {
+    const { extraMultiStepHandlers = [] } = options;
+    let networks = initialProps.networks;
+    let networkAdapter = initialProps.networkAdapter;
+    const fuelConnectionService = new FuelConnectionService();
+    fuelConnectionService.setNetworks(networks, networkAdapter);
+    const unregisterWalletSynchronizer = registerFuelWalletSynchronizer(() => fuelConnectionService.syncConnectedWallets());
+    const transferProvider = createFuelTransfer();
+    const transfer = transferProvider.executeTransfer;
+    return createMemoizedConnectionStore({
+        computeInputs: () => {
+            const fuelState = useFuelStore.getState();
+            return {
+                connectors: fuelState.connectors,
+                fuel: fuelState.fuel,
+                ready: fuelState.ready,
+                connectedWallets: fuelState.connectedWallets,
+                networks,
+            };
+        },
+        buildSnapshot: () => ({
+            ...fuelConnectionService.buildProvider(),
+            transfer,
+            multiStepHandlers: extraMultiStepHandlers,
+        }),
+        subscribe: sync => [
+            useFuelStore.subscribe(sync),
+        ],
+        onUpdateProps: nextProps => {
+            networks = nextProps.networks;
+            networkAdapter = nextProps.networkAdapter;
+            fuelConnectionService.setNetworks(networks, networkAdapter);
+        },
+        onDestroy: unregisterWalletSynchronizer,
+    });
+}

package/dist/esm/service/fuelStore.js

@@ -0,0 +1,26 @@
+import { create } from 'zustand';
+export const useFuelStore = create()((set) => ({
+    connectors: [],
+    fuel: undefined,
+    ready: false,
+    connectedWallets: [],
+    // `fuel.connectors()` returns the SAME array instance on every call and
+    // mutates `installed`/`connected` on the connector objects in place. A
+    // stored reference would defeat every downstream identity memo — the
+    // provider snapshot would never recompute after its first build, freezing
+    // stale `extensionNotFound` flags in the UI. Copy on write so every
+    // publish is a fresh identity.
+    _setConnectors: (connectors) => set({ connectors: [...connectors], ready: connectors.length > 0 }),
+    _setFuel: (fuel) => set({ fuel }),
+    // Mirrors the global wallet store's dedupe-by-(id,address) semantics so the
+    // same connector reconnecting replaces its entry instead of appending.
+    connectWallet: (wallet) => set((state) => {
+        const filtered = state.connectedWallets.filter(w => !(w.id === wallet.id && w.address === wallet.address));
+        return { connectedWallets: [...filtered, wallet] };
+    }),
+    disconnectWallet: (connectorName) => set((state) => ({
+        connectedWallets: connectorName
+            ? state.connectedWallets.filter(w => w.id !== connectorName)
+            : [],
+    })),
+}));

package/dist/esm/service/getFuel.js

@@ -0,0 +1,13 @@
+let _instance = null;
+export function setFuelInstance(instance) {
+    _instance = instance;
+}
+export function getFuelInstance() {
+    if (!_instance) {
+        throw new Error('Fuel instance requested before initFuelProvider() ran');
+    }
+    return _instance;
+}
+export function hasFuelInstance() {
+    return _instance !== null;
+}

package/dist/esm/service/syncFuel.js

@@ -0,0 +1,119 @@
+import { FuelConnectorEventTypes } from '@fuel-ts/account';
+import { useFuelStore } from './fuelStore';
+let _attached = false;
+let _dispose = null;
+let _fuel = null;
+const walletSynchronizers = new Set();
+export function registerFuelWalletSynchronizer(sync) {
+    walletSynchronizers.add(sync);
+    return () => {
+        walletSynchronizers.delete(sync);
+    };
+}
+async function syncConnectedWallets() {
+    await Promise.allSettled([...walletSynchronizers].map(sync => sync()));
+}
+export function attachFuelSync(fuel) {
+    if (_fuel === fuel && _dispose)
+        return _dispose;
+    _dispose?.();
+    useFuelStore.getState()._setFuel(fuel);
+    const refreshConnectors = async () => {
+        try {
+            const connectors = await fuel.connectors();
+            useFuelStore.getState()._setConnectors(connectors);
+            // Re-attach per-connector network listeners whenever the list changes
+            attachConnectorNetworkListeners(connectors);
+        }
+        catch {
+            // swallow
+        }
+    };
+    const onConnection = () => {
+        syncConnectedWallets().catch(() => { });
+    };
+    const onCurrentConnector = () => {
+        syncConnectedWallets().catch(() => { });
+    };
+    let perConnectorDisposers = [];
+    function attachConnectorNetworkListeners(connectors) {
+        // Detach previous listeners
+        perConnectorDisposers.forEach(fn => fn());
+        perConnectorDisposers = [];
+        for (const c of connectors) {
+            const handler = async () => {
+                await syncConnectedWallets();
+            };
+            c.on(FuelConnectorEventTypes.currentNetwork, handler);
+            perConnectorDisposers.push(() => c.off(FuelConnectorEventTypes.currentNetwork, handler));
+        }
+    }
+    // Refresh connector detection flags, then sync sessions the refreshed
+    // flags reveal. Shared by initial population, bounded re-detection and
+    // the window-focus refresh below.
+    const refreshAll = () => refreshConnectors()
+        .then(() => syncConnectedWallets())
+        .catch(() => { });
+    const onConnectors = () => { void refreshAll(); };
+    let retryTimers = [];
+    const onWindowFocus = () => { void refreshAll(); };
+    let disposed = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        fuel.off(FuelConnectorEventTypes.connectors, onConnectors);
+        fuel.off(FuelConnectorEventTypes.connection, onConnection);
+        fuel.off(FuelConnectorEventTypes.currentConnector, onCurrentConnector);
+        perConnectorDisposers.forEach(fn => fn());
+        perConnectorDisposers = [];
+        retryTimers.forEach(t => clearTimeout(t));
+        retryTimers = [];
+        if (typeof window !== 'undefined')
+            window.removeEventListener('focus', onWindowFocus);
+        if (_dispose !== dispose)
+            return;
+        _attached = false;
+        _dispose = null;
+        _fuel = null;
+    };
+    try {
+        fuel.on(FuelConnectorEventTypes.connectors, onConnectors);
+        fuel.on(FuelConnectorEventTypes.connection, onConnection);
+        fuel.on(FuelConnectorEventTypes.currentConnector, onCurrentConnector);
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+    _attached = true;
+    _fuel = fuel;
+    _dispose = dispose;
+    // Initial population. The SDK restores the stored connector during Fuel's
+    // constructor with `emitEvents: false`, which skips the `connection` event,
+    // and its early `currentConnector` emit races the store population above —
+    // so no event reliably announces a restored session. `fuel.connectors()`
+    // refreshes each connector's `connected` flag, so a sync chained after it
+    // picks the restored session up deterministically.
+    void refreshAll();
+    // Detection is not one-shot-reliable: extension content scripts and MV3
+    // service workers can come up after the initial ping, and a wallet that
+    // announced itself before our listeners attached is silent forever after.
+    // The pre-refactor @fuels/react layer re-polled connectors; mirror that
+    // with a bounded re-detection pass (spaced beyond the SDK's 5s ping cache)
+    // plus a refresh on window focus — which also picks up an extension the
+    // user just installed from the "Install" prompt, or unlocked via popup.
+    if (typeof window !== 'undefined') {
+        const RETRY_DELAYS_MS = [6000, 14000];
+        retryTimers = RETRY_DELAYS_MS.map(delay => setTimeout(() => {
+            const connectors = useFuelStore.getState().connectors;
+            if (connectors.length === 0 || connectors.some(c => !c.installed))
+                void refreshAll();
+        }, delay));
+        window.addEventListener('focus', onWindowFocus);
+    }
+    return _dispose;
+}
+export function isFuelSyncAttached() {
+    return _attached;
+}

package/dist/esm/transferProvider/{useFuelTransfer.js → createFuelTransfer.js}

@@ -1,23 +1,23 @@
-import { ActionMessageType } from "@layerswap/widget/types";
-import { useFuel } from '@fuels/react';
+import { ActionMessageType } from '@layerswap/widget-types';
 import { Provider } from '@fuel-ts/account';
 import { transactionBuilder } from "./transactionBuilder";
-import { KnownInternalNames } from "@layerswap/widget/internal";
+import { KnownInternalNames } from "@layerswap/utils";
+import { getFuelInstance, hasFuelInstance } from "../service/getFuel";
 const supportedNetworks = [
     KnownInternalNames.Networks.FuelTestnet,
     KnownInternalNames.Networks.FuelDevnet,
     KnownInternalNames.Networks.FuelMainnet
 ];
-export function useFuelTransfer() {
-    const { fuel } = useFuel();
+export function createFuelTransfer() {
     return {
         supportsNetwork(network) {
             return supportedNetworks.includes(network.name);
         },
         async executeTransfer(params) {
-            if (!fuel) {
+            if (!hasFuelInstance()) {
                 throw new Error("Fuel not initialized");
             }
+            const fuel = getFuelInstance();
             const { callData, network, selectedWallet, swapId } = params;
             const fuelProvider = new Provider(network.node_url);
             const fuelWallet = await fuel.getWallet(selectedWallet.address, fuelProvider);

package/dist/esm/utils/index.js

@@ -1,2 +1 @@
-export * from "./KnownFuelConnectors";
 export * from "./resolveIcon";

package/dist/esm/utils/resolveIcon.js

@@ -1,9 +1,4 @@
-import { walletIconResolver } from "@layerswap/widget/internal";
-import KnownFuelConnectors from "./KnownFuelConnectors";
-export const resolveFuelWalletConnectorIcon = ({ connector, address, iconUrl }) => {
-    const knownConnector = KnownFuelConnectors.find(c => c.id.toLowerCase() === connector?.toLowerCase());
-    if (knownConnector && knownConnector.icon)
-        return knownConnector.icon;
-    else
-        return walletIconResolver(address, iconUrl);
+import { resolveWalletIconString } from "@layerswap/wallet-core";
+export const resolveFuelWalletConnectorIcon = ({ connector, iconUrl }) => {
+    return resolveWalletIconString({ id: connector, iconUrl });
 };