@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/fuels/connectors/fuelet-wallet/FueletWalletConnector.js

@@ -1,20 +1,19 @@
-// import type { ConnectorMetadata } from 'fuels';
-// import { APP_IMAGE_DARK, APP_IMAGE_LIGHT } from './constants';
-// import { FuelWalletConnector } from '../fuel-wallet';
-// export class FueletWalletConnector extends FuelWalletConnector {
-//     name = 'Fuelet Wallet';
-//     metadata: ConnectorMetadata = {
-//         image: {
-//             light: APP_IMAGE_LIGHT,
-//             dark: APP_IMAGE_DARK,
-//         },
-//         install: {
-//             action: 'Install',
-//             description: 'Install Fuelet Wallet in order to connect it.',
-//             link: 'https://fuelet.app/download/',
-//         },
-//     };
-//     constructor() {
-//         super('Fuelet Wallet');
-//     }
-// }
+import { APP_IMAGE_DARK, APP_IMAGE_LIGHT } from './constants';
+import { FuelWalletConnector } from '../fuel-wallet';
+export class FueletWalletConnector extends FuelWalletConnector {
+    constructor() {
+        super('Fuelet Wallet');
+        this.name = 'Fuelet Wallet';
+        this.metadata = {
+            image: {
+                light: APP_IMAGE_LIGHT,
+                dark: APP_IMAGE_DARK,
+            },
+            install: {
+                action: 'Install',
+                description: 'Install Fuelet Wallet in order to connect it.',
+                link: 'https://fuelet.app/download/',
+            },
+        };
+    }
+}

package/dist/lib/fuels/connectors/fuelet-wallet/index.d.ts

@@ -0,0 +1 @@
+export { FueletWalletConnector } from './FueletWalletConnector';

package/dist/lib/fuels/connectors/fuelet-wallet/index.js

@@ -1 +1 @@
-// export { FueletWalletConnector } from './FueletWalletConnector';
+export { FueletWalletConnector } from './FueletWalletConnector';

package/dist/lib/fuels/connectors/walletConnect/WalletConnectConnector.js

@@ -0,0 +1,422 @@
+// import {
+//   ecrecover,
+//   fromRpcSig,
+//   hashPersonalMessage,
+//   hexToBytes,
+//   pubToAddress,
+// } from '@ethereumjs/util';
+// import { hexlify, splitSignature } from '@ethersproject/bytes';
+// import {
+//   type Config,
+//   type GetAccountReturnType,
+//   disconnect,
+//   getAccount,
+//   reconnect,
+//   watchAccount,
+// } from '@wagmi/core';
+// // import type { Web3Modal } from '@web3modal/wagmi';
+// import {
+//   CHAIN_IDS,
+//   type ConnectorMetadata,
+//   FuelConnectorEventTypes,
+//   Provider as FuelProvider,
+//   LocalStorage,
+//   type StorageAbstract,
+//   type TransactionRequestLike,
+// } from 'fuels';
+// // import {
+// //   type EIP1193Provider,
+// //   EthereumWalletAdapter,
+// //   type Maybe,
+// //   PredicateConnector,
+// //   type PredicateVersion,
+// //   type PredicateWalletAdapter,
+// //   type ProviderDictionary,
+// //   getMockedSignatureIndex,
+// //   getOrThrow,
+// //   getProviderUrl,
+// // } from '@fuel-connectors/common';
+// // import { ApiController } from '@web3modal/core';
+// import {
+//   ETHEREUM_ICON,
+//   HAS_WINDOW,
+//   SINGATURE_VALIDATION_TIMEOUT,
+//   WINDOW,
+// } from './constants';
+// import type { WalletConnectConfig } from './types';
+// import { subscribeAndEnforceChain } from './utils';
+// // import { createWagmiConfig, createWeb3ModalInstance } from './web3Modal';
+// import { EIP1193Provider, EthereumWalletAdapter, Maybe, PredicateConnector, PredicateVersion, PredicateWalletAdapter, ProviderDictionary, getMockedSignatureIndex, getOrThrow, getProviderUrl } from '../../common';
+// import { AppKit } from '@reown/appkit/react'
+// import { PREDICATE_VERSIONS } from '../../evm-predicates';
+// export class WalletConnectConnector extends PredicateConnector {
+//   name = 'Ethereum Wallets';
+//   installed = true;
+//   events = FuelConnectorEventTypes;
+//   metadata: ConnectorMetadata = {
+//     image: ETHEREUM_ICON,
+//     install: {
+//       action: 'Install',
+//       description: 'Install Ethereum Wallet to connect to Fuel',
+//       link: 'https://ethereum.org/en/wallets/find-wallet/',
+//     },
+//   };
+//   private fuelProvider!: FuelProvider;
+//   private ethProvider!: EIP1193Provider;
+//   private appKit!: AppKit;
+//   private storage: StorageAbstract;
+//   private config: WalletConnectConfig = {} as WalletConnectConfig;
+//   constructor(config: WalletConnectConfig) {
+//     super();
+//     this.storage =
+//       config.storage || new LocalStorage(WINDOW?.localStorage as Storage);
+//     const wagmiConfig = config.wagmiConfig
+//     if (wagmiConfig._internal.syncConnectedChain !== false) {
+//       subscribeAndEnforceChain(wagmiConfig);
+//     }
+//     this.customPredicate = config.predicateConfig || null;
+//     if (HAS_WINDOW) {
+//       this.configProviders({ ...config, wagmiConfig });
+//     }
+//     this.loadPersistedConnection();
+//   }
+//   private async loadPersistedConnection() {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!wagmiConfig) return;
+//     await this.config?.fuelProvider;
+//     await this.requireConnection();
+//     await this.handleConnect(
+//       getAccount(wagmiConfig),
+//       await this.getAccountAddress(),
+//     );
+//   }
+//   // createModal re-instanciates the modal to update singletons from web3modal
+//   private createModal() {
+//     this.clearSubscriptions();
+//     // this.appKit = this.modalFactory(this.config);
+//     // ApiController.prefetch();
+//     this.setupWatchers();
+//   }
+//   // private modalFactory(config: WalletConnectConfig) {
+//   //   return createWeb3ModalInstance({
+//   //     projectId: config.projectId,
+//   //     wagmiConfig: config.wagmiConfig,
+//   //   });
+//   // }
+//   private async handleConnect(
+//     account: NonNullable<GetAccountReturnType<Config>>,
+//     defaultAccount: string | null = null,
+//   ) {
+//     const address = defaultAccount ?? (account?.address as string);
+//     if (!(await this.accountHasValidation(address))) return;
+//     if (!address) return;
+//     await this.setupPredicate();
+//     this.emit(this.events.connection, true);
+//     this.emit(
+//       this.events.currentAccount,
+//       this.predicateAccount?.getPredicateAddress(address),
+//     );
+//     this.emit(
+//       this.events.accounts,
+//       this.predicateAccount?.getPredicateAddresses(await this.walletAccounts()),
+//     );
+//   }
+//   private setupWatchers() {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!wagmiConfig) throw new Error('Wagmi config not found');
+//     this.subscribe(
+//       watchAccount(wagmiConfig, {
+//         onChange: async (account) => {
+//           switch (account.status) {
+//             case 'connected': {
+//               await this.handleConnect(account);
+//               break;
+//             }
+//             case 'disconnected': {
+//               this.emit(this.events.connection, false);
+//               this.emit(this.events.currentAccount, null);
+//               this.emit(this.events.accounts, []);
+//               break;
+//             }
+//           }
+//         },
+//       }),
+//     );
+//   }
+//   protected getWagmiConfig(): Maybe<Config> {
+//     return this.config?.wagmiConfig;
+//   }
+//   protected getWalletAdapter(): PredicateWalletAdapter {
+//     return new EthereumWalletAdapter();
+//   }
+//   protected getPredicateVersions(): Record<string, PredicateVersion> {
+//     return PREDICATE_VERSIONS;
+//   }
+//   protected async configProviders(config: WalletConnectConfig) {
+//     const network = getProviderUrl(config?.chainId ?? CHAIN_IDS.fuel.testnet);
+//     // this.config = Object.assign(config, {
+//     //   fuelProvider: config.fuelProvider || FuelProvider.create(network),
+//     // });
+//   }
+//   protected async walletAccounts(): Promise<Array<string>> {
+//     return Promise.resolve((await this.getAccountAddresses()) as Array<string>);
+//   }
+//   protected async getAccountAddress(): Promise<Maybe<string>> {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!wagmiConfig) return null;
+//     const addresses = await this.getAccountAddresses();
+//     if (!addresses) return null;
+//     const address = addresses[0];
+//     if (!address) return null;
+//     if (!(await this.accountHasValidation(address))) return null;
+//     return address;
+//   }
+//   protected async getAccountAddresses(): Promise<Maybe<readonly string[]>> {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!wagmiConfig) return null;
+//     const addresses = getAccount(wagmiConfig).addresses || [];
+//     const accountsValidations = await this.getAccountValidations(
+//       addresses as `0x${string}`[],
+//     );
+//     return addresses.filter((_, i) => accountsValidations[i]);
+//   }
+//   protected async requireConnection() {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!this.appKit) this.createModal();
+//     if (this.config.skipAutoReconnect || !wagmiConfig) return;
+//     const { status, connections } = wagmiConfig.state;
+//     if (status === 'disconnected' && connections.size > 0) {
+//       await reconnect(wagmiConfig);
+//     }
+//   }
+//   protected async getProviders(): Promise<ProviderDictionary> {
+//     if (this.fuelProvider && this.ethProvider) {
+//       return {
+//         fuelProvider: this.fuelProvider,
+//         ethProvider: this.ethProvider,
+//       };
+//     }
+//     if (!this.fuelProvider) {
+//       this.fuelProvider = getOrThrow(
+//         await this.config.fuelProvider,
+//         'Fuel provider is not available',
+//       );
+//     }
+//     const wagmiConfig = this.getWagmiConfig();
+//     const ethProvider = wagmiConfig
+//       ? ((await getAccount(
+//         wagmiConfig,
+//       ).connector?.getProvider?.()) as EIP1193Provider)
+//       : undefined;
+//     return {
+//       fuelProvider: this.fuelProvider,
+//       ethProvider,
+//     };
+//   }
+//   public async connect(): Promise<boolean> {
+//     this.createModal();
+//     const result = await new Promise<boolean>((resolve, reject) => {
+//       this.config.wagmiConfig.connectors.find((c) => c.id === 'walletConnect')?.connect()
+//       const wagmiConfig = this.getWagmiConfig();
+//       const unsub = this.appKit.subscribeEvents(async (event) => {
+//         const requestValidations = () => {
+//           this.requestValidations()
+//             .then(() => resolve(true))
+//             .catch((err) => reject(err))
+//             .finally(() => unsub());
+//         };
+//         switch (event.data.event) {
+//           case 'MODAL_OPEN':
+//             if (wagmiConfig) {
+//               const account = getAccount(wagmiConfig);
+//               if (account?.isConnected) {
+//                 unsub();
+//                 this.appKit.close();
+//                 requestValidations();
+//                 break;
+//               }
+//             }
+//             // Ensures that the WC Web3Modal config is applied over pre-existing states (e.g. Solan Connect Web3Modal)
+//             this.createModal();
+//             break;
+//           case 'CONNECT_SUCCESS': {
+//             requestValidations();
+//             break;
+//           }
+//           case 'MODAL_CLOSE':
+//           case 'CONNECT_ERROR': {
+//             if (wagmiConfig) {
+//               const account = getAccount(wagmiConfig);
+//               if (account) {
+//                 requestValidations();
+//                 break;
+//               }
+//             }
+//             resolve(false);
+//             unsub();
+//             break;
+//           }
+//         }
+//       });
+//     });
+//     return result;
+//   }
+//   private async getAccountValidations(
+//     accounts: `0x${string}`[] | string[],
+//   ): Promise<boolean[]> {
+//     return Promise.all(
+//       accounts.map(async (a) => {
+//         const isValidated = await this.storage.getItem(
+//           `SIGNATURE_VALIDATION_${a}`,
+//         );
+//         return isValidated === 'true';
+//       }),
+//     );
+//   }
+//   private async accountHasValidation(
+//     account: `0x${string}` | string | undefined,
+//   ) {
+//     if (!account) return false;
+//     const [hasValidate] = await this.getAccountValidations([account]);
+//     return hasValidate;
+//   }
+//   async requestValidations() {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!wagmiConfig) {
+//       throw new Error('Wagmi config not found');
+//     }
+//     const account = getAccount(wagmiConfig);
+//     const { addresses } = account;
+//     for (const address of addresses || []) {
+//       await this.requestValidation(address)
+//         .then(() => {
+//           this.handleConnect(account);
+//         })
+//         .catch((err) => {
+//           this.disconnect();
+//           throw err;
+//         });
+//     }
+//   }
+//   async requestValidation(address?: string) {
+//     return new Promise(async (resolve, reject) => {
+//       // Disconnect if user dosen't provide signature in time
+//       const validationTimeout = setTimeout(() => {
+//         reject(
+//           new Error("User didn't provide signature in less than 1 minute"),
+//         );
+//       }, SINGATURE_VALIDATION_TIMEOUT);
+//       const { ethProvider } = await this.getProviders();
+//       if (!ethProvider) return;
+//       await new Promise((resolve) => setTimeout(resolve, 1000));
+//       this.signAndValidate(ethProvider, address)
+//         .then(() => {
+//           clearTimeout(validationTimeout);
+//           this.storage.setItem(`SIGNATURE_VALIDATION_${address}`, 'true');
+//           resolve(true);
+//         })
+//         .catch((err) => {
+//           clearTimeout(validationTimeout);
+//           reject(err);
+//         });
+//     });
+//   }
+//   public async disconnect(): Promise<boolean> {
+//     const wagmiConfig = this.getWagmiConfig();
+//     if (!wagmiConfig) throw new Error('Wagmi config not found');
+//     const { addresses, connector, isConnected } = getAccount(wagmiConfig);
+//     await disconnect(wagmiConfig, {
+//       connector,
+//     });
+//     addresses?.map((a) => this.storage.removeItem(`SIGNATURE_VALIDATION_${a}`));
+//     return isConnected || false;
+//   }
+//   public async sendTransaction(
+//     address: string,
+//     transaction: TransactionRequestLike,
+//   ): Promise<string> {
+//     const { ethProvider, fuelProvider } = await this.getProviders();
+//     const { request, transactionId, account, transactionRequest } =
+//       await this.prepareTransaction(address, transaction);
+//     const signature = (await ethProvider?.request({
+//       method: 'personal_sign',
+//       params: [transactionId, account],
+//     })) as string;
+//     const predicateSignatureIndex = getMockedSignatureIndex(
+//       transactionRequest.witnesses,
+//     );
+//     // Transform the signature into compact form for Sway to understand
+//     const compactSignature = splitSignature(hexToBytes(signature)).compact;
+//     transactionRequest.witnesses[predicateSignatureIndex] = compactSignature;
+//     const transactionWithPredicateEstimated =
+//       await fuelProvider.estimatePredicates(request);
+//     const response = await fuelProvider.operations.submit({
+//       encodedTransaction: hexlify(
+//         transactionWithPredicateEstimated.toTransactionBytes(),
+//       ),
+//     });
+//     return response.submit.id;
+//   }
+//   private validateSignature(
+//     account: string,
+//     message: string,
+//     signature: string,
+//   ) {
+//     const msgBuffer = Uint8Array.from(Buffer.from(message));
+//     const msgHash = hashPersonalMessage(msgBuffer);
+//     const { v, r, s } = fromRpcSig(signature as any);
+//     const pubKey = ecrecover(msgHash, v, r, s);
+//     const recoveredAddress = Buffer.from(pubToAddress(pubKey)).toString('hex');
+//     // The recovered address doesn't have the 0x prefix
+//     return recoveredAddress.toLowerCase() === account.toLowerCase().slice(2);
+//   }
+//   private async signAndValidate(
+//     ethProvider: EIP1193Provider | undefined,
+//     account?: string,
+//   ) {
+//     try {
+//       if (!ethProvider) {
+//         throw new Error('No Ethereum provider found');
+//       }
+//       if (account && !account.startsWith('0x')) {
+//         throw new Error('Invalid account address');
+//       }
+//       const currentAccount =
+//         account ||
+//         (
+//           (await ethProvider.request({
+//             method: 'eth_requestAccounts',
+//           })) as string[]
+//         )[0];
+//       if (!currentAccount) {
+//         throw new Error('No Ethereum account selected');
+//       }
+//       const message = `Sign this message to verify the connected account: ${currentAccount}`;
+//       const signature = (await ethProvider.request({
+//         method: 'personal_sign',
+//         params: [message, currentAccount],
+//       })) as string;
+//       if (!this.validateSignature(currentAccount, message, signature)) {
+//         throw new Error('Signature address validation failed');
+//       }
+//       return true;
+//     } catch (error) {
+//       this.disconnect();
+//       throw error;
+//     }
+//   }
+//   async signMessageCustomCurve(message: string) {
+//     const { ethProvider } = await this.getProviders();
+//     if (!ethProvider) throw new Error('Eth provider not found');
+//     const accountAddress = await this.getAccountAddress();
+//     if (!accountAddress) throw new Error('No connected accounts');
+//     const signature = await ethProvider.request({
+//       method: 'personal_sign',
+//       params: [accountAddress, message],
+//     });
+//     return {
+//       curve: 'secp256k1',
+//       signature: signature as string,
+//     };
+//   }
+// }

package/dist/lib/fuels/connectors/walletConnect/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_PROJECT_ID = "00000000000000000000000000000000";
+export declare const ETHEREUM_ICON = "data:image/svg+xml;utf8;base64,PHN2ZyB3aWR0aD0iNTEyIiBoZWlnaHQ9IjUxMiIgdmlld0JveD0iMCAwIDUxMiA1MTIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik0yNTMgMzM1LjEyMkwyNTUuODg2IDMzOEwzODggMjU5Ljk4N0wyNTUuODg2IDQxTDI1MyA1MC43OTgzVjMzNS4xMjJaIiBmaWxsPSIjMzQzNDM0Ii8+CjxwYXRoIGQ9Ik0yNTYgMzM4VjQxTDEyNCAyNTkuOTg2TDI1NiAzMzhaIiBmaWxsPSIjOEM4QzhDIi8+CjxwYXRoIGQ9Ik0yNTQgNDY1LjI4MUwyNTUuNjI4IDQ3MEwzODggMjg1TDI1NS42MjkgMzYyLjU2M0wyNTQuMDAxIDM2NC41MzJMMjU0IDQ2NS4yODFaIiBmaWxsPSIjM0MzQzNCIi8+CjxwYXRoIGQ9Ik0xMjQgMjg1TDI1NiA0NzBWMzYyLjU2MkwxMjQgMjg1WiIgZmlsbD0iIzhDOEM4QyIvPgo8cGF0aCBkPSJNMjU2IDIwMFYzMzhMMzg4IDI1OS45ODhMMjU2IDIwMFoiIGZpbGw9IiMxNDE0MTQiLz4KPHBhdGggZD0iTTI1NiAyMDBMMTI0IDI1OS45ODhMMjU2IDMzOFYyMDBaIiBmaWxsPSIjMzkzOTM5Ii8+Cjwvc3ZnPgo=";
+export declare const TESTNET_URL = "https://testnet.fuel.network/v1/graphql";
+export declare const SINGATURE_VALIDATION_TIMEOUT: number;
+export declare const HAS_WINDOW: boolean;
+export declare const WINDOW: (Window & typeof globalThis) | null;

package/dist/lib/fuels/connectors/walletConnect/constants.js

@@ -0,0 +1,7 @@
+export const DEFAULT_PROJECT_ID = '00000000000000000000000000000000';
+export const ETHEREUM_ICON = 'data:image/svg+xml;utf8;base64,PHN2ZyB3aWR0aD0iNTEyIiBoZWlnaHQ9IjUxMiIgdmlld0JveD0iMCAwIDUxMiA1MTIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik0yNTMgMzM1LjEyMkwyNTUuODg2IDMzOEwzODggMjU5Ljk4N0wyNTUuODg2IDQxTDI1MyA1MC43OTgzVjMzNS4xMjJaIiBmaWxsPSIjMzQzNDM0Ii8+CjxwYXRoIGQ9Ik0yNTYgMzM4VjQxTDEyNCAyNTkuOTg2TDI1NiAzMzhaIiBmaWxsPSIjOEM4QzhDIi8+CjxwYXRoIGQ9Ik0yNTQgNDY1LjI4MUwyNTUuNjI4IDQ3MEwzODggMjg1TDI1NS42MjkgMzYyLjU2M0wyNTQuMDAxIDM2NC41MzJMMjU0IDQ2NS4yODFaIiBmaWxsPSIjM0MzQzNCIi8+CjxwYXRoIGQ9Ik0xMjQgMjg1TDI1NiA0NzBWMzYyLjU2MkwxMjQgMjg1WiIgZmlsbD0iIzhDOEM4QyIvPgo8cGF0aCBkPSJNMjU2IDIwMFYzMzhMMzg4IDI1OS45ODhMMjU2IDIwMFoiIGZpbGw9IiMxNDE0MTQiLz4KPHBhdGggZD0iTTI1NiAyMDBMMTI0IDI1OS45ODhMMjU2IDMzOFYyMDBaIiBmaWxsPSIjMzkzOTM5Ii8+Cjwvc3ZnPgo=';
+export const TESTNET_URL = 'https://testnet.fuel.network/v1/graphql';
+// 1 minute timeout for request signature
+export const SINGATURE_VALIDATION_TIMEOUT = 1000 * 60;
+export const HAS_WINDOW = typeof window !== 'undefined';
+export const WINDOW = HAS_WINDOW ? window : null;

package/dist/lib/fuels/connectors/walletConnect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './utils';

package/dist/lib/fuels/connectors/walletConnect/index.js

@@ -0,0 +1,3 @@
+// export * from './WalletConnectConnector';
+export * from './types';
+export * from './utils';

package/dist/lib/fuels/connectors/walletConnect/types.d.ts

@@ -0,0 +1,12 @@
+import type { Config as WagmiConfig } from '@wagmi/core';
+import type { Provider as FuelProvider, StorageAbstract } from 'fuels';
+import { PredicateConfig } from '../../common';
+export type WalletConnectConfig = {
+    fuelProvider?: FuelProvider | Promise<FuelProvider>;
+    projectId?: string;
+    wagmiConfig: WagmiConfig;
+    predicateConfig?: PredicateConfig;
+    storage?: StorageAbstract;
+    chainId?: number;
+    skipAutoReconnect?: boolean;
+};

package/dist/lib/fuels/connectors/walletConnect/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/fuels/connectors/walletConnect/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './subscribeAndEnforceChain';

package/dist/lib/fuels/connectors/walletConnect/utils/index.js

@@ -0,0 +1 @@
+export * from './subscribeAndEnforceChain';

package/dist/lib/fuels/connectors/walletConnect/utils/subscribeAndEnforceChain.d.ts

@@ -0,0 +1,2 @@
+import { type Config } from '@wagmi/core';
+export declare function subscribeAndEnforceChain(config: Config): void;

package/dist/lib/fuels/connectors/walletConnect/utils/subscribeAndEnforceChain.js

@@ -0,0 +1,39 @@
+import { disconnect, getChains, switchChain, } from '@wagmi/core';
+function getCurrentChainId(state) {
+    return state.current
+        ? state.connections.get(state.current)?.chainId
+        : undefined;
+}
+export function subscribeAndEnforceChain(config) {
+    if (!config)
+        throw new Error('config is required');
+    config.subscribe((state) => ({
+        connections: state.connections,
+        status: state.status,
+        current: state.current,
+    }), (state, _prev) => {
+        const chains = getChains(config);
+        if (state.status !== 'connected' || state.current == null)
+            return;
+        const connector = state.connections.get(state.current)?.connector;
+        const currentChain = getCurrentChainId(state);
+        if (currentChain != null &&
+            !chains.some((chain) => chain.id === currentChain)) {
+            // Some EVM Wallets (like MetaMask) will auto-reject calls made too quickly.
+            setTimeout(() => {
+                switchChain(config, {
+                    chainId: chains[0].id,
+                    connector,
+                }).catch((error) => {
+                    console.log(error);
+                    disconnect(config);
+                });
+            }, 2000);
+        }
+    }, {
+        equalityFn: (a, b) => {
+            return (getCurrentChainId(a) === getCurrentChainId(b) && a.status === b.status);
+        },
+    });
+    // wagmiCo
+}

package/dist/lib/fuels/connectors/walletConnect/web3Modal.js

@@ -0,0 +1,50 @@
+// import { http, type Config, createConfig, injected } from '@wagmi/core';
+// import { DEFAULT_PROJECT_ID } from './constants';
+// import { createAppKit, AppKit } from '@reown/appkit/react'
+// import { arbitrum, mainnet, sepolia } from '@reown/appkit/networks'
+// import { WagmiAdapter } from '@reown/appkit-adapter-wagmi'
+// import { EthereumProvider } from '@walletconnect/ethereum-provider'
+// export const createWagmiConfig = (): Config =>
+//   createConfig({
+//     chains: [sepolia, mainnet],
+//     syncConnectedChain: true,
+//     transports: {
+//       [mainnet.id]: http(),
+//       [sepolia.id]: http(),
+//     },
+//     connectors: [injected({ shimDisconnect: false })],
+//   });
+// interface CreateWeb3ModalProps {
+//   adapter: WagmiAdapter | undefined;
+//   projectId?: string;
+// }
+// export function createWeb3ModalInstance({
+//   adapter,
+//   projectId = DEFAULT_PROJECT_ID,
+// }: CreateWeb3ModalProps): AppKit {
+//   if (!projectId) {
+//     console.warn(
+//       '[WalletConnect Connector]: Get a project ID on https://cloud.walletconnect.com to use WalletConnect features.',
+//     );
+//   }
+//   return createAppKit({
+//     adapters: [adapter!],
+//     networks: [mainnet, arbitrum],
+//     projectId,
+//     allWallets: 'ONLY_MOBILE',
+//     features: {
+//       analytics: false,
+//     }
+//   })
+//   // return createWeb3Modal({
+//   //   wagmiConfig: {
+//   //     ...wagmiConfig,
+//   //     // @ts-ignore
+//   //     enableWalletConnect: !!projectId,
+//   //   },
+//   //   allWallets: 'ONLY_MOBILE',
+//   //   enableAnalytics: false,
+//   //   allowUnsupportedChain: true,
+//   //   projectId: projectId,
+//   // });
+// }

package/dist/lib/gases/gasResolver.d.ts

@@ -1,5 +1,5 @@
 import { GasProps } from "../../Models/Balance";
 export declare class GasResolver {
     private providers;
-    getGas({ address, network, token, recipientAddress }: GasProps): Promise<number | undefined> | undefined;
+    getGas({ address, network, token, recipientAddress }: GasProps): Promise<any> | undefined;
 }

package/dist/lib/gases/gasResolver.js

@@ -1,20 +1,20 @@
 import { EVMGasProvider } from "./providers/evmGasProvider";
-// import { FuelGasProvider } from "./providers/fuelGasProvider";
-// import { LoopringGasProvider } from "./providers/loopringGasProvider";
-// import { SolanaGasProvider } from "./providers/solanaGasProvider";
-// import { StarknetGasProvider } from "./providers/starknetGasProvider";
-// import { TronGasProvider } from "./providers/tronGasProvider";
+import { FuelGasProvider } from "./providers/fuelGasProvider";
+import { LoopringGasProvider } from "./providers/loopringGasProvider";
+import { SolanaGasProvider } from "./providers/solanaGasProvider";
+import { TronGasProvider } from "./providers/tronGasProvider";
 import { ZkSyncGasProvider } from "./providers/zkSyncGasProvider";
 export class GasResolver {
     constructor() {
         this.providers = [
+            // new BitcoinGasProvider(),
             // new StarknetGasProvider(),
+            new LoopringGasProvider(),
             new EVMGasProvider(),
-            // new FuelGasProvider(),
-            // new LoopringGasProvider(),
-            // new SolanaGasProvider(),
+            new FuelGasProvider(),
+            new SolanaGasProvider(),
             new ZkSyncGasProvider(),
-            // new TronGasProvider()
+            new TronGasProvider()
         ];
     }
     getGas({ address, network, token, recipientAddress }) {

package/dist/lib/gases/providers/bitcoinGasProvider.d.ts

@@ -0,0 +1,6 @@
+import { GasProps } from "../../../Models/Balance";
+import { Network } from "../../../Models/Network";
+export declare class BitcoinGasProvider {
+    supportsNetwork(network: Network): boolean;
+    getGas({ network }: GasProps): Promise<any>;
+}