dequanto 0.1.39 → 0.1.45

package/lib/types/wallets/EIP6963ProviderFactory.d.ts

@@ -0,0 +1,47 @@
+import { TAddress } from '../models/TAddress';
+import { TEth } from '../models/TEth';
+import { TGlobal } from '../utils/$ref';
+import { class_EventEmitter } from 'atma-utils';
+import { IEIP6963Provider } from '../rpc/transports/compatibility/IEIP6963Provider';
+interface EIP6963ProviderInfo {
+    rdns?: string;
+    uuid: string;
+    name: string;
+    icon?: string;
+    chainId?: number;
+}
+export interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: IEIP6963Provider;
+    accounts?: TEth.Address[];
+}
+interface IProviderEvents {
+    onProviderRegistered: (detail: EIP6963ProviderDetail) => void;
+    onProviderConnected: (detail: EIP6963ProviderDetail, chainId: number) => void;
+    onAccountsConnected: (detail: EIP6963ProviderDetail, accounts: TAddress[]) => void;
+    onAccountsDisconnected: (detail: EIP6963ProviderDetail) => void;
+    onChainChanged: (detail: EIP6963ProviderDetail, chainId: number) => void;
+    onAccountsChanged: (detail: EIP6963ProviderDetail, accounts: TEth.Address[]) => void;
+}
+export declare class EIP6963ProviderFactory extends class_EventEmitter<IProviderEvents> {
+    private listeners;
+    providers: EIP6963ProviderDetail[];
+    selected: EIP6963ProviderDetail;
+    global: TGlobal;
+    constructor();
+    isConnected(address?: TEth.Address): boolean;
+    connect(id?: string): Promise<`0x${string}`[]>;
+    disconnect(): void;
+    useProvider(id: string): void;
+    getProviders(): EIP6963ProviderDetail[];
+    requestAccounts(id?: string): Promise<TEth.Address[]>;
+    private requestProvider;
+    private listenToNewProvider;
+    private onAnnounceProvider;
+    getProviderOrFirst(id?: string): EIP6963ProviderDetail;
+    getProvider(id?: string, optional?: boolean): EIP6963ProviderDetail;
+    private getId;
+    private addEventListeners;
+    private removeEventListeners;
+}
+export {};

package/lib/types/wallets/Signer.d.ts

@@ -0,0 +1,15 @@
+import { TEth } from '../models/TEth';
+import { Rpc, RpcTypes } from '../rpc/Rpc';
+export declare class Signer implements TEth.IRpcSigner {
+    opts: {
+        rpc?: Rpc;
+    } & Partial<TEth.IRpcSigner>;
+    constructor(opts: {
+        rpc?: Rpc;
+    } & Partial<TEth.IRpcSigner>);
+    eth_sign(account: TEth.Address, data: TEth.Hex): Promise<TEth.Hex>;
+    eth_signTransaction(tx: TEth.TxLike): Promise<TEth.Hex>;
+    eth_signTypedData_v4(address: TEth.Address, typedData: Partial<RpcTypes.TypedData>): Promise<TEth.Hex>;
+    personal_sign(challenge: string, address: TEth.Address): Promise<TEth.Hex>;
+    protected call(method: keyof TEth.IRpcSigner, params: any[]): Promise<any>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.1.39",
+    "version": "0.1.45",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"

package/src/clients/ClientPool.ts

@@ -7,38 +7,35 @@ import { $contract } from '@dequanto/utils/$contract';
 import { $logger, l } from '@dequanto/utils/$logger';
 import { $promise } from '@dequanto/utils/$promise';
 import { $array } from '@dequanto/utils/$array';
-import { $bigint } from '@dequanto/utils/$bigint';
 
 import { PromiseEventWrap } from './model/PromiEventWrap';
 import { IWeb3ClientStatus } from './interfaces/IWeb3ClientStatus';
 import { ClientStatus } from './model/ClientStatus';
 import { ClientPoolTrace, ClientPoolTraceError, ErrorCode } from './ClientPoolStats';
-import { class_Dfr, obj_extendDefaults } from 'atma-utils';
+import { class_Dfr } from 'atma-utils';
 import { ClientErrorUtil } from './utils/ClientErrorUtil';
 import { IWeb3ClientOptions } from './interfaces/IWeb3Client';
 import { RateLimitGuard } from './handlers/RateLimitGuard';
 import { Web3BatchRequests } from './Web3BatchRequests';
 
-import { HttpTransport } from '@dequanto/rpc/transports/HttpTransport';
-import { WsTransport } from '@dequanto/rpc/transports/WsTransport';
-import { Rpc } from '@dequanto/rpc/Rpc';
+import { Rpc, RpcTypes } from '@dequanto/rpc/Rpc';
 
-import { Web3Transport } from '@dequanto/rpc/transports/compatibility/Web3Transport';
 import { PromiseEvent } from '@dequanto/class/PromiseEvent';
 import { TTransport } from '@dequanto/rpc/transports/ITransport';
 
 import { TRpc } from '@dequanto/rpc/RpcBase';
 import { TEth } from '@dequanto/models/TEth';
 import { $rpc } from '@dequanto/rpc/$rpc';
-import { Web3 } from './compatibility/Web3';
+import { DataLike } from '@dequanto/utils/types';
 
-export interface IPoolClientConfig {
+export interface IRpcConfig {
     url?: string
     options?: TTransport.Options.Http | TTransport.Options.Ws
 
-    /** Will be a pefered node for submitting transactions */
+    /** Will be a preferred node for submitting transactions */
     safe?: boolean
     distinct?: boolean
+    wallet?: boolean
 
     web3?: TTransport.Transport | Promise<TTransport.Transport>
 
@@ -52,7 +49,7 @@ export interface IPoolClientConfig {
     /** True if the node supports traceTransaction calls */
     traceable?: boolean
 
-    // requestCout/timeSpan: e.g. 100/1min
+    // requestCount/timeSpan: e.g. 100/1min
     rateLimit?: string
 
     // the max block range to fetch per single request when getting Logs
@@ -70,6 +67,9 @@ export interface IPoolClientConfig {
 export interface IPoolWeb3Request {
     ws?: boolean
     preferSafe?: boolean
+
+    /** Request wallet node to submit unsigned transactions */
+    wallet?: boolean
     distinct?: boolean
     name?: string
 
@@ -248,9 +248,29 @@ export class ClientPool {
         return max;
     }
 
+    wrappedPromiEvent <T> (asyncFactory: () => Promise<T>): PromiseEvent<T> {
+        let promiEvent = new PromiseEventWrap();
+
+        asyncFactory().then(
+            (result) => {
+                promiEvent.resolve(result);
+            },
+            (error) => {
+                promiEvent.reject(error);
+            }
+        );
+        return promiEvent as any as PromiseEvent<T>;
+    }
+
     callPromiEvent<TResult extends PromiseEvent<any>>(
         fn: (web3: WClient) => TResult
-        , opts?: { preferSafe?: boolean, parallel?: number, silent?: boolean, distinct?: boolean }
+        , opts?: {
+            preferSafe?: boolean,
+            parallel?: number,
+            silent?: boolean,
+            distinct?: boolean,
+            wallet?: boolean
+        }
         , used: Map<WClient, number> = new Map<WClient, number>()
         , errors = []
         , root?: PromiseEventWrap
@@ -381,7 +401,7 @@ export class ClientPool {
                 return null;
             }
             let promise = method(wClient);
-            return options?.timeout == null ? promise : $promise.timeout(promise, options.timeout);
+            return options?.timeout == null ? promise : $promise.timeout(promise, options.timeout, `${methodName} in ${ wClient.config?.url }`);
         }
 
         let nodes = await alot(this.clients).mapAsync(async (wClient, idx) => {
@@ -397,7 +417,8 @@ export class ClientPool {
                 ]);
                 let blockNumber = Number(blockNumberUint);
 
-                let ping = Math.round((Date.now() - start) / 4);
+                let requestsCount = options?.calls?.length ?? 4
+                let ping = Math.round((Date.now() - start) / requestsCount);
                 let blockNumberBehind = 0;
                 if (syncing?.currentBlock && syncing.currentBlock < blockNumber) {
                     blockNumberBehind = blockNumber - Number(syncing.currentBlock);
@@ -528,6 +549,9 @@ export class ClientPool {
                 healthy = safe;
             }
         }
+        if (opts?.wallet === true) {
+            healthy = healthy.filter(x => x.config.wallet === true);
+        }
 
         let arr = healthy.length > 0
             ? healthy
@@ -722,7 +746,7 @@ export class WClient {
 
     rpc: Rpc
 
-    config: IPoolClientConfig
+    config: IRpcConfig
     rateLimitGuard: RateLimitGuard
 
     /** For getLogs method, as some providers limit the range request or page result value */
@@ -772,7 +796,7 @@ export class WClient {
         }
     }
 
-    constructor(mix: IPoolClientConfig) {
+    constructor(mix: IRpcConfig) {
         const hasUrl = 'url' in mix && typeof mix.url === 'string';
         const hasWeb3 = 'web3' in mix && typeof mix.web3 != null;
         if (hasUrl || hasWeb3) {
@@ -877,6 +901,16 @@ export class WClient {
         return promise;
     }
 
+    sign (address: TEth.Address, message: string): Promise<string> {
+        return this.rpc.eth_sign(address, message);
+    }
+
+    signTypedData (address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex> {
+        return this
+            .rpc
+            .eth_signTypedData_v4(address, typedData);
+    }
+
     async callBatched<TResult = any>(requests: TRpc.IRpcAction[]): Promise<TResult[]> {
         let total = requests.length;
         let spanLimit = this.getSpanLimit(requests.length);

package/src/clients/WalletClient.ts

@@ -0,0 +1,115 @@
+import di from 'a-di';
+import { TEth } from '@dequanto/models/TEth';
+import { Rpc, RpcTypes } from '@dequanto/rpc/Rpc';
+import { $require } from '@dequanto/utils/$require';
+import { DataLike } from '@dequanto/utils/types';
+import { EIP6963ProviderDetail, EIP6963ProviderFactory } from '@dequanto/wallets/EIP6963ProviderFactory';
+import { WClient } from './ClientPool';
+import { $hex } from '@dequanto/utils/$hex';
+
+/** Wallet actions only. For all Node (Chain) related actions - Web3Client should be used */
+
+export class WalletClient {
+    public factory: EIP6963ProviderFactory;
+
+    constructor (factory?: EIP6963ProviderFactory) {
+        this.factory = factory ?? di.resolve(EIP6963ProviderFactory);
+    }
+
+    // Client abstract methods
+
+    //Set the provider by UUID as the default one for eth_** methods
+    async useProvider (uuid: string) {
+        this.factory.useProvider(uuid);
+    }
+
+    async getProvider (uuid?: string): Promise<EIP6963ProviderDetail> {
+        return this.factory.getProvider(uuid, true);
+    }
+
+    async getProviders (): Promise<EIP6963ProviderDetail[]> {
+        let { providers } = this.factory;
+        return providers;
+    }
+
+    async getAccounts (uuid?: string): Promise<TEth.Address[]> {
+        let rpc = this.getRpc(uuid);
+        return rpc.eth_accounts();
+    }
+
+    /** Find the provider by UUID or use the first one to connect to and to requestAccounts */
+    async connect (uuid?: string): Promise<TEth.Address[]> {
+        return this.factory.connect(uuid);
+    }
+
+    async disconnect () {
+        this.factory.disconnect();
+    }
+
+    isConnected (address?: TEth.Address): boolean {
+        return this.factory.isConnected(address);
+    }
+
+    // RPC methods
+    eth_accounts () {
+        let rpc = this.getRpc();
+        return rpc.eth_accounts();
+    }
+
+    eth_requestAccounts () {
+        let rpc = this.getRpc();
+        return rpc.eth_requestAccounts();
+    }
+
+    eth_sign (address: TEth.Address, message: string): Promise<string> {
+        let rpc = this.getRpc();
+        return rpc.eth_sign(address, message);
+    }
+
+    eth_signTypedData_v4 (address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>) {
+        let rpc = this.getRpc();
+        return rpc.eth_signTypedData_v4(address, typedData);
+    }
+
+    eth_sendTransaction (...args: Parameters<Rpc['eth_sendTransaction']>) {
+        let rpc = this.getRpc();
+        return rpc.eth_sendTransaction(...args);
+    }
+
+    eth_chainId (...args: Parameters<Rpc['eth_chainId']>) {
+        let rpc = this.getRpc();
+        return rpc.eth_chainId(...args);
+    }
+
+    wallet_addEthereumChain (...args: Parameters<Rpc['wallet_addEthereumChain']>) {
+        let rpc = this.getRpc();
+        return rpc.wallet_addEthereumChain(...args);
+    }
+
+    wallet_switchEthereumChain (...args: Parameters<Rpc['wallet_switchEthereumChain']>) {
+        let rpc = this.getRpc();
+        return rpc.wallet_switchEthereumChain(...args);
+    }
+
+    async getClientFor (chainId: number) {
+        let { selected } = this.factory;
+        $require.notNull(selected, 'No selected EIP6963 provider');
+        let client = new WClient({ web3: selected.provider as any });
+
+        let providerChainId = await client.rpc.eth_chainId();
+        if (providerChainId !== chainId) {
+            await client.rpc.wallet_switchEthereumChain({
+                chainId: $hex.ensure(chainId)
+            });
+            providerChainId = await client.rpc.eth_chainId();
+            $require.eq(providerChainId, chainId, 'Chain ID mismatch');
+        }
+
+        return client;
+    }
+
+    private getRpc (uuid?: string) {
+        let p = this.factory.getProvider(uuid, false);
+        return new Rpc(p.provider)
+    }
+}

package/src/clients/Web3Client.ts

@@ -6,7 +6,7 @@ import type { TPlatform } from '@dequanto/models/TPlatform';
 
 import type { IWeb3Client, IWeb3ClientOptions } from './interfaces/IWeb3Client';
 
-import { ClientPool, IPoolClientConfig, IPoolWeb3Request, WClient } from './ClientPool';
+import { ClientPool, IRpcConfig, IPoolWeb3Request, WClient } from './ClientPool';
 import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
 import { $number } from '@dequanto/utils/$number';
 
@@ -31,6 +31,7 @@ import { $sig } from '@dequanto/utils/$sig';
 import { DataLike } from '@dequanto/utils/types';
 import { ErrorCode } from './ClientPoolStats';
 import { $date } from '@dequanto/utils/$date';
+import { WalletClient } from './WalletClient';
 
 export abstract class Web3Client implements IWeb3Client {
 
@@ -58,20 +59,14 @@ export abstract class Web3Client implements IWeb3Client {
         return this.forked?.platform ?? this.platform;
     }
 
-    async sign(txData: TEth.TxLike, privateKey: TEth.Hex): Promise<string> {
-        let rpc = await this.getRpc();
-        let sig = await $sig.signTx( txData, { key: privateKey }, rpc);
-        let tx = $sig.TxSerializer.serialize(txData, sig);
-        return tx;
-    }
-
     public options: IWeb3ClientOptions;
     public pool: ClientPool;
     public debug: ClientDebugMethods;
+    public wallet = di.resolve(WalletClient);
 
     constructor(options: IWeb3ClientOptions)
-    constructor(endpoints: IPoolClientConfig[])
-    constructor(mix: IWeb3ClientOptions | IPoolClientConfig[]) {
+    constructor(endpoints: IRpcConfig[])
+    constructor(mix: IWeb3ClientOptions | IRpcConfig[]) {
         if (Array.isArray(mix)) {
             this.options = { endpoints: mix }
         } else if (mix != null) {
@@ -159,10 +154,7 @@ export abstract class Web3Client implements IWeb3Client {
     ): Promise<RpcSubscription<TEth.Hex>>;
     async subscribe(type, ...params): Promise<RpcSubscription<any>> {
         let wClient = await this.pool.getWrappedWeb3({ ws: true });
-        console.log(`Check ensure connected`);
         await wClient.ensureConnected();
-        console.log(`Check ensure connectd OK`);
-
         switch (type) {
             case 'newBlockHeaders':
                 type = 'newHeads';
@@ -398,10 +390,49 @@ export abstract class Web3Client implements IWeb3Client {
         }, { preferSafe: true, distinct: true });
     }
 
+    // async signTx(txData: TEth.TxLike, privateKey: TEth.Hex): Promise<string> {
+    //     let rpc = await this.getRpc();
+    //     let sig = await $sig.signTx( txData, { key: privateKey }, rpc);
+    //     let tx = $sig.TxSerializer.serialize(txData, sig);
+    //     return tx;
+    // }
+
+    async sign(address: TEth.Address, message: string): Promise<string> {
+        if (this.wallet.isConnected(address)) {
+            return this.wallet.eth_sign(address, message);
+        }
+        return this.pool.call(wClient => {
+            return wClient.sign(address, message);
+        }, {
+            wallet: true
+        });
+    }
+
+    signTypedData(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex> {
+        if (this.wallet.isConnected(address)) {
+            return this.wallet.eth_signTypedData_v4(address, typedData);
+        }
+        return this.pool.call(wClient => {
+            return wClient.signTypedData(address, typedData);
+        }, {
+            wallet: true
+        });
+    }
+
     sendTransaction(data: TEth.TxLike): PromiseEvent<TEth.TxReceipt> {
+        if (this.wallet.isConnected(data.from)) {
+            return this.pool.wrappedPromiEvent <TEth.TxReceipt> (async () => {
+                let client = await this.wallet.getClientFor(this.chainId);
+                return client.sendTransaction(data);
+            });
+        }
         return this.pool.callPromiEvent(wClient => {
             return wClient.sendTransaction(data);
-        }, { preferSafe: true, distinct: true });
+        }, {
+            preferSafe: true,
+            distinct: true,
+            wallet: this.platform === 'hardhat' ? void 0 : true
+        });
     }
 
     getBlockNumber() {
@@ -514,9 +545,9 @@ export abstract class Web3Client implements IWeb3Client {
     }
 
     static url<T extends Web3Client>(options: IWeb3ClientOptions)
-    static url<T extends Web3Client>(endpoints: IPoolClientConfig[], opts?: Partial<IWeb3ClientOptions>)
+    static url<T extends Web3Client>(endpoints: IRpcConfig[], opts?: Partial<IWeb3ClientOptions>)
     static url<T extends Web3Client>(url: string, opts?: Partial<IWeb3ClientOptions>): T
-    static url<T extends Web3Client>(mix: IWeb3ClientOptions | IPoolClientConfig[] | string, opts?: Partial<IWeb3ClientOptions>): T {
+    static url<T extends Web3Client>(mix: IWeb3ClientOptions | IRpcConfig[] | string, opts?: Partial<IWeb3ClientOptions>): T {
         const Ctor: any = this;
         let options: IWeb3ClientOptions;
         if (typeof mix === 'string') {

package/src/clients/Web3ClientFactory.ts

@@ -1,5 +1,4 @@
 import di from 'a-di';
-import alot from 'alot';
 import { TPlatform } from '@dequanto/models/TPlatform';
 import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
 import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
@@ -7,54 +6,24 @@ import { Config } from '@dequanto/config/Config';
 import { EvmWeb3Client } from './EvmWeb3Client';
 import { $require } from '@dequanto/utils/$require';
 import { $config } from '@dequanto/utils/$config';
-import { IConfigData } from '@dequanto/config/interface/IConfigData';
 
 export namespace Web3ClientFactory {
 
-    export function get (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions) {
-        let web3 = $config.get<IConfigData['web3']>('web3');
-        if (typeof platform ==='number') {
-            let chain = alot.fromObject(web3).find(x => x.value.chainId === platform);
-            if (chain == null) {
-                throw new Error(`Unsupported platform ${platform} for web3 client`);
-            }
-            platform = chain.key
-        }
-        if (platform === 'hardhat' || platform.startsWith('hh:')) {
+    export function get (platform: TPlatform | number, opts?: IWeb3EndpointOptions) {
+        if (typeof platform === 'string' && (platform === 'hardhat' || platform.startsWith('hh:'))) {
             let client = di.resolve(HardhatProvider).client('localhost', opts);
             if (platform.startsWith('hh:')) {
                 client.configureFork(platform.slice(3));
             }
             return client;
         }
-        let cfg = web3[platform];
-        $require.notNull(cfg, `Unsupported platform ${platform} for web3 client`)
-        return new EvmWeb3Client({ platform, ...cfg });
 
-        // switch (platform) {
-        //     case 'bsc':
-        //         return di.resolve(BscWeb3Client, opts);
-        //     case 'eth':
-        //         return di.resolve(EthWeb3Client, opts);
-        //     case 'eth:goerli':
-        //         return di.resolve(EthWeb3Client, {
-        //             platform: platform,
-        //             chainId: 5,
-        //             ...(opts ?? {})
-        //         });
-        //     case 'polygon':
-        //         return di.resolve(PolyWeb3Client, opts);
-        //     case 'arbitrum':
-        //         return di.resolve(ArbWeb3Client, opts);
-        //     case 'xdai':
-        //         return di.resolve(XDaiWeb3Client, opts);
-        //     default:
-        //         let cfg = config.web3[platform];
-        //         if (cfg != null) {
-        //             return new EvmWeb3Client({ platform, ...cfg });
-        //         }
-        //         throw new Error(`Unsupported platform ${platform} for web3 client`);
-        // }
+        let options = $config.getWeb3Options(platform);
+        $require.notNull(options, `Unsupported platform ${platform} for web3 client`)
+        return new EvmWeb3Client({
+            ...options,
+            ...(opts ?? {})
+        });
     }
 
     /** Same as sync variation, but ensures the config is being fetched */

package/src/clients/interfaces/IWeb3Client.ts

@@ -1,21 +1,16 @@
-import { TBufferLike } from '@dequanto/models/TBufferLike';
 import { TPlatform } from '@dequanto/models/TPlatform';
-
-import { IPoolClientConfig } from '../ClientPool';
-import { TEth } from '@dequanto/models/TEth';
+import { IRpcConfig } from '../ClientPool';
 import { TTransport } from '@dequanto/rpc/transports/ITransport';
 
 export interface IWeb3Client {
     platform: string
     chainId: number
     defaultGasLimit: number
-
-    sign (txData: TEth.Tx, privateKey: string): Promise<TBufferLike>
 }
 
 
 export interface IWeb3ClientOptions {
-    endpoints: IPoolClientConfig[]
+    endpoints: IRpcConfig[]
     platform?: TPlatform
     chainId?: number
     // Token symbol: e.g. ETH

package/src/config/AConfigBase.ts

@@ -1,5 +1,7 @@
+import { IRpcConfig } from '@dequanto/clients/ClientPool'
 import { IConfigData } from './interface/IConfigData'
-
+import { TPlatform } from '@dequanto/models/TPlatform'
+import { TEth } from '@dequanto/models/TEth'
 
 type TConfigParamsBase = {
     config?: Partial<IConfigData>
@@ -18,16 +20,6 @@ export type TConfigParamsBrowser = TConfigParamsBase & {
 }
 export type TConfigParams = TConfigParamsNode | TConfigParamsBrowser;
 
-export interface IProviderEndpoint {
-    url: string
-    private?: boolean
-    safe?: boolean
-
-    // Is not used in general ClientPool, only retrievable via getWeb3 method.
-    manual?: boolean
-
-    traceable?: boolean
-}
 
 export interface IConfigProvider {
 

package/src/config/Config.ts

@@ -15,7 +15,7 @@ export class Config {
 
         obj_extend(config, cfg);
 
-        if (config.web3 == null) {
+        if (config.web3 == null && config.chains == null) {
             let message = `web3 is not defined in the config file`;
             $logger.log(message);
             singleton.reject(new Error(message));
@@ -34,6 +34,11 @@ export class Config {
         return Config.fetch();
     }
 
+    // static async getExplorerConfig (platform: TPlatform | number): Promise<TExplorer> {
+    //     let config = await Config.get();
+
+    // }
+
     static async extend (json) {
         await provider.extend(json);
     }

package/src/config/ConfigDefaults.ts

@@ -7,6 +7,7 @@ export const ConfigDefaults = <IConfigData> {
         }
     },
     "tokens": null,
+    "chains": null,
     "blockchainExplorer": {
         "bsc": {
             "key": "MB1EM53BDJFKDIHUZ5JJT946BJJUQIHFP2",
@@ -116,14 +117,10 @@ export const ConfigDefaults = <IConfigData> {
             "chainToken": "ETH",
             "endpoints": [
                 {
-                    "url": "https://eth.public-rpc.com"
+                    "url": "https://ethereum-rpc.publicnode.com"
                 },
                 {
-                    "url": "https://main-light.eth.linkpool.io",
-                    "rateLimit": "2000/5m"
-                },
-                {
-                    "url": "wss://main-light.eth.linkpool.io/ws",
+                    "url": "https://eth.drpc.org",
                     "rateLimit": "2000/5m"
                 }
             ]

package/src/config/ConfigProvider.ts

@@ -101,14 +101,18 @@ export class ConfigProvider implements IConfigProvider {
     }
 
     private async getSourcesBrowser (parameters: TConfigParamsNode) {
-        return [
+        let sources = [
             {
                 config: {
                     ...ConfigDefaults,
                     ...(parameters?.config ?? {}),
                 }
             },
+            {
+                localStorage: '0xweb/config'
+            }
         ];
+        return sources;
     }
 }
 

package/src/config/interface/IConfigData.ts

@@ -2,7 +2,8 @@ import { IContractDetails } from '@dequanto/models/IContractDetails';
 import { ITokenGlob } from '@dequanto/models/ITokenGlob';
 import { TAddress } from '@dequanto/models/TAddress';
 import { TPlatform } from '@dequanto/models/TPlatform';
-import { IProviderEndpoint } from '../AConfigBase';
+import { IRpcConfig } from '@dequanto/clients/ClientPool';
+import { TChain } from '@dequanto/models/TChain';
 
 
 export interface IConfigData {
@@ -31,11 +32,15 @@ export interface IConfigData {
             host: string;
         };
     };
+
+    chains: TChain[]
+
     web3: {
         [platform in TPlatform]: {
-            chainId?: number;
-            chainToken?: string;
-            endpoints: IProviderEndpoint[];
+            chainId?: number
+            chainToken?: string
+            aliases?: string[]
+            endpoints: IRpcConfig[]
         };
     };
     contracts?: {