dequanto 0.1.39 → 0.1.45

package/lib/esm/wallets/Signer.mjs

@@ -0,0 +1,26 @@
+export class Signer {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    eth_sign(account, data) {
+        return this.call('eth_sign', [account, data]);
+    }
+    eth_signTransaction(tx) {
+        return this.call('eth_signTransaction', [tx]);
+    }
+    eth_signTypedData_v4(address, typedData) {
+        return this.call('eth_signTypedData_v4', [address, typedData]);
+    }
+    personal_sign(challenge, address) {
+        return this.call('personal_sign', [challenge, address]);
+    }
+    call(method, params) {
+        let fn = this.opts[method] ?? this.opts.rpc[method];
+        if (typeof fn === 'function') {
+            return fn(...params);
+        }
+        throw new Error(`Method ${method} not found in Signer`);
+    }
+}
+//# sourceMappingURL=Signer.js.map
+//# sourceMappingURL=Signer.ts.map

package/lib/types/clients/ClientPool.d.ts

@@ -5,17 +5,19 @@ import { ClientPoolTrace } from './ClientPoolStats';
 import { IWeb3ClientOptions } from './interfaces/IWeb3Client';
 import { RateLimitGuard } from './handlers/RateLimitGuard';
 import { Web3BatchRequests } from './Web3BatchRequests';
-import { Rpc } from '../rpc/Rpc';
+import { Rpc, RpcTypes } from '../rpc/Rpc';
 import { PromiseEvent } from '../class/PromiseEvent';
 import { TTransport } from '../rpc/transports/ITransport';
 import { TRpc } from '../rpc/RpcBase';
 import { TEth } from '../models/TEth';
-export interface IPoolClientConfig {
+import { DataLike } from '../utils/types';
+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>;
     name?: string;
     /** Will be used only if manually requested with .getWeb3, or .getNodeUrl */
@@ -35,6 +37,8 @@ export interface IPoolClientConfig {
 export interface IPoolWeb3Request {
     ws?: boolean;
     preferSafe?: boolean;
+    /** Request wallet node to submit unsigned transactions */
+    wallet?: boolean;
     distinct?: boolean;
     name?: string;
     /** HTTP Web3 Client traces */
@@ -68,11 +72,13 @@ export declare class ClientPool {
     getNodeURL(options?: IPoolWeb3Request): Promise<string>;
     releaseWeb3(): Promise<void>;
     getOptionForFetchableRange(blockRangeLimits?: WClient['blockRangeLimits']): number;
+    wrappedPromiEvent<T>(asyncFactory: () => Promise<T>): PromiseEvent<T>;
     callPromiEvent<TResult extends PromiseEvent<any>>(fn: (web3: WClient) => TResult, opts?: {
         preferSafe?: boolean;
         parallel?: number;
         silent?: boolean;
         distinct?: boolean;
+        wallet?: boolean;
     }, used?: Map<WClient, number>, errors?: any[], root?: PromiseEventWrap): TResult;
     getNodeStats(): {
         success: number;
@@ -105,7 +111,7 @@ export declare class WClient {
         ping: number;
     };
     rpc: Rpc;
-    config: IPoolClientConfig;
+    config: IRpcConfig;
     rateLimitGuard: RateLimitGuard;
     /** For getLogs method, as some providers limit the range request or page result value */
     blockRangeLimits: {
@@ -116,7 +122,7 @@ export declare class WClient {
     healthy(): boolean;
     private updateRateLimitInfo;
     updateBlockRangeInfo(info: WClient['blockRangeLimits']): void;
-    constructor(mix: IPoolClientConfig);
+    constructor(mix: IRpcConfig);
     send<TResult>(fn: (web3: WClient) => PromiseEvent<TResult>): Promise<{
         status: ClientStatus;
         error?: any;
@@ -124,6 +130,8 @@ export declare class WClient {
     }>;
     sendSignedTransaction(tx: TEth.Hex): PromiseEvent<TEth.TxReceipt>;
     sendTransaction(tx: any): PromiseEvent<TEth.TxReceipt>;
+    sign(address: TEth.Address, message: string): Promise<string>;
+    signTypedData(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex>;
     callBatched<TResult = any>(requests: TRpc.IRpcAction[]): Promise<TResult[]>;
     call<TResult extends PromiseLike<any>>(fn: (wClient: WClient) => TResult, options?: {
         batchRequestCount?: number;

package/lib/types/clients/WalletClient.d.ts

@@ -0,0 +1,28 @@
+import { TEth } from '../models/TEth';
+import { Rpc, RpcTypes } from '../rpc/Rpc';
+import { DataLike } from '../utils/types';
+import { EIP6963ProviderDetail, EIP6963ProviderFactory } from '../wallets/EIP6963ProviderFactory';
+import { WClient } from './ClientPool';
+/** Wallet actions only. For all Node (Chain) related actions - Web3Client should be used */
+export declare class WalletClient {
+    factory: EIP6963ProviderFactory;
+    constructor(factory?: EIP6963ProviderFactory);
+    useProvider(uuid: string): Promise<void>;
+    getProvider(uuid?: string): Promise<EIP6963ProviderDetail>;
+    getProviders(): Promise<EIP6963ProviderDetail[]>;
+    getAccounts(uuid?: string): Promise<TEth.Address[]>;
+    /** Find the provider by UUID or use the first one to connect to and to requestAccounts */
+    connect(uuid?: string): Promise<TEth.Address[]>;
+    disconnect(): Promise<void>;
+    isConnected(address?: TEth.Address): boolean;
+    eth_accounts(): Promise<`0x${string}`[]>;
+    eth_requestAccounts(): Promise<`0x${string}`[]>;
+    eth_sign(address: TEth.Address, message: string): Promise<string>;
+    eth_signTypedData_v4(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<`0x${string}`>;
+    eth_sendTransaction(...args: Parameters<Rpc['eth_sendTransaction']>): Promise<`0x${string}`>;
+    eth_chainId(...args: Parameters<Rpc['eth_chainId']>): Promise<number>;
+    wallet_addEthereumChain(...args: Parameters<Rpc['wallet_addEthereumChain']>): Promise<undefined>;
+    wallet_switchEthereumChain(...args: Parameters<Rpc['wallet_switchEthereumChain']>): Promise<undefined>;
+    getClientFor(chainId: number): Promise<WClient>;
+    private getRpc;
+}

package/lib/types/clients/Web3Client.d.ts

@@ -1,7 +1,7 @@
 import type { TAbiItem } from '../types/TAbi';
 import type { TPlatform } from '../models/TPlatform';
 import type { IWeb3Client, IWeb3ClientOptions } from './interfaces/IWeb3Client';
-import { ClientPool, IPoolClientConfig, IPoolWeb3Request, WClient } from './ClientPool';
+import { ClientPool, IRpcConfig, IPoolWeb3Request, WClient } from './ClientPool';
 import { ClientEventsStream } from './ClientEventsStream';
 import { ClientDebugMethods } from './debug/ClientDebugMethods';
 import { TRpcContractCall } from '../rpc/RpcContract';
@@ -11,6 +11,7 @@ import { PromiseEvent } from '../class/PromiseEvent';
 import { Rpc, RpcTypes } from '../rpc/Rpc';
 import { TRpc } from '../rpc/RpcBase';
 import { DataLike } from '../utils/types';
+import { WalletClient } from './WalletClient';
 export declare abstract class Web3Client implements IWeb3Client {
     TIMEOUT: number;
     abstract platform: TPlatform;
@@ -25,12 +26,12 @@ export declare abstract class Web3Client implements IWeb3Client {
     defaultGasPriceRatio: number;
     blockTimeAvg: number;
     get network(): TPlatform;
-    sign(txData: TEth.TxLike, privateKey: TEth.Hex): Promise<string>;
     options: IWeb3ClientOptions;
     pool: ClientPool;
     debug: ClientDebugMethods;
+    wallet: WalletClient;
     constructor(options: IWeb3ClientOptions);
-    constructor(endpoints: IPoolClientConfig[]);
+    constructor(endpoints: IRpcConfig[]);
     request<TResult = any>(req: TRpc.IRpcAction): Promise<TResult>;
     batch(requests: TRpc.IRpcAction[]): Promise<any[]>;
     getEventStream(address: TEth.Address, abi: TAbiItem[], event: string): ClientEventsStream<any>;
@@ -76,6 +77,8 @@ export declare abstract class Web3Client implements IWeb3Client {
         chainId: number | string;
     }, options: IPoolWeb3Request): Promise<void>;
     sendSignedTransaction(signedTxBuffer: TEth.Hex): PromiseEvent<TEth.TxReceipt>;
+    sign(address: TEth.Address, message: string): Promise<string>;
+    signTypedData(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex>;
     sendTransaction(data: TEth.TxLike): PromiseEvent<TEth.TxReceipt>;
     getBlockNumber(): Promise<number>;
     call(tx: TEth.TxLike): Promise<any>;
@@ -107,7 +110,7 @@ export declare abstract class Web3Client implements IWeb3Client {
         url: string;
     }[];
     static url<T extends Web3Client>(options: IWeb3ClientOptions): any;
-    static url<T extends Web3Client>(endpoints: IPoolClientConfig[], opts?: Partial<IWeb3ClientOptions>): any;
+    static url<T extends Web3Client>(endpoints: IRpcConfig[], opts?: Partial<IWeb3ClientOptions>): any;
     static url<T extends Web3Client>(url: string, opts?: Partial<IWeb3ClientOptions>): T;
 }
 export type TLogsRangeProgress<TLogParsed> = {

package/lib/types/clients/Web3ClientFactory.d.ts

@@ -2,7 +2,7 @@ import { TPlatform } from '../models/TPlatform';
 import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
 import { EvmWeb3Client } from './EvmWeb3Client';
 export declare namespace Web3ClientFactory {
-    function get(platform: TPlatform | string | number, opts?: IWeb3EndpointOptions): import("../hardhat/HardhatWeb3Client").HardhatWeb3Client | EvmWeb3Client;
+    function get(platform: TPlatform | number, opts?: IWeb3EndpointOptions): import("../hardhat/HardhatWeb3Client").HardhatWeb3Client | EvmWeb3Client;
     /** Same as sync variation, but ensures the config is being fetched */
     function getAsync(platform: TPlatform | string | number, opts?: IWeb3EndpointOptions): Promise<import("../hardhat/HardhatWeb3Client").HardhatWeb3Client | EvmWeb3Client>;
 }

package/lib/types/clients/interfaces/IWeb3Client.d.ts

@@ -1,16 +1,13 @@
-import { TBufferLike } from '../../models/TBufferLike';
 import { TPlatform } from '../../models/TPlatform';
-import { IPoolClientConfig } from '../ClientPool';
-import { TEth } from '../../models/TEth';
+import { IRpcConfig } from '../ClientPool';
 import { TTransport } from '../../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;
     chainToken?: string;

package/lib/types/config/AConfigBase.d.ts

@@ -11,13 +11,6 @@ export type TConfigParamsNode = TConfigParamsBase & {
 };
 export type TConfigParamsBrowser = TConfigParamsBase & {};
 export type TConfigParams = TConfigParamsNode | TConfigParamsBrowser;
-export interface IProviderEndpoint {
-    url: string;
-    private?: boolean;
-    safe?: boolean;
-    manual?: boolean;
-    traceable?: boolean;
-}
 export interface IConfigProvider {
     fetch(parameters?: TConfigParamsBase): Promise<IConfigData>;
     extend(json?: Partial<IConfigData>): Promise<void>;

package/lib/types/config/interface/IConfigData.d.ts

@@ -2,7 +2,8 @@ import { IContractDetails } from '../../models/IContractDetails';
 import { ITokenGlob } from '../../models/ITokenGlob';
 import { TAddress } from '../../models/TAddress';
 import { TPlatform } from '../../models/TPlatform';
-import { IProviderEndpoint } from '../AConfigBase';
+import { IRpcConfig } from '../../clients/ClientPool';
+import { TChain } from '../../models/TChain';
 export interface IConfigData {
     settings: {
         /** Root path of the dequanto library */
@@ -27,11 +28,13 @@ export interface IConfigData {
             host: string;
         };
     };
+    chains: TChain[];
     web3: {
         [platform in TPlatform]: {
             chainId?: number;
             chainToken?: string;
-            endpoints: IProviderEndpoint[];
+            aliases?: string[];
+            endpoints: IRpcConfig[];
         };
     };
     contracts?: {

package/lib/types/explorer/BlockchainExplorer.d.ts

@@ -5,6 +5,8 @@ import { TAddress } from '../models/TAddress';
 import { TPlatform } from '../models/TPlatform';
 import { TEth } from '../models/TEth';
 import { IVerifier } from './verifiers/IVerifier';
+import { TExplorer, TExplorerDefinition } from '../models/TExplorer';
+/** @deprecated use TExplorerDefinition instead */
 export interface IBlockchainExplorerConfig {
     key?: string;
     api?: string;
@@ -17,6 +19,7 @@ export interface IBlockchainExplorerConfig {
         verification?: boolean | 'fs';
     }[];
 }
+/** @deprecated use TExplorerDefinition instead */
 export interface IBlockchainExplorerFactoryParams extends IBlockchainExplorerConfig {
     platform?: string;
     ABI_CACHE?: string;
@@ -33,12 +36,12 @@ type TxFilter = {
 export declare class BlockchainExplorer implements IBlockchainExplorer {
     client: HttpClient;
     inMemoryDb: IContractDetails[];
-    config: IBlockchainExplorerConfig;
     fsVerification: IVerifier;
-    opts: IBlockchainExplorerFactoryParams;
+    config: TExplorer;
     platform: TPlatform;
-    constructor(opts?: IBlockchainExplorerFactoryParams);
-    constructor(platform?: TPlatform);
+    getWeb3: (platform: any) => Web3Client;
+    constructor(config: TExplorerDefinition);
+    constructor(opts: IBlockchainExplorerFactoryParams);
     getContractMeta(name: string): any;
     getContractMeta(address: string): any;
     getContractCreation(address: TAddress): Promise<{

package/lib/types/explorer/BlockchainExplorerFactory.d.ts

@@ -1,15 +1,19 @@
 import { IBlockchainExplorer } from './IBlockchainExplorer';
 import { Constructor } from '../utils/types';
-import { BlockchainExplorer, IBlockchainExplorerFactoryParams } from './BlockchainExplorer';
+import { IBlockchainExplorerFactoryParams } from './BlockchainExplorer';
 import { TPlatform } from '../models/TPlatform';
+import { TExplorerDefinition } from '../models/TExplorer';
 /**
  * @obsolete Use BlockchainExplorer class instead.
  */
 export declare namespace BlockchainExplorerFactory {
     function register(platform: TPlatform, explorer: IBlockchainExplorer | Constructor<IBlockchainExplorer>): void;
-    function get(platform: TPlatform | string, opts?: IBlockchainExplorerFactoryParams): IBlockchainExplorer | BlockchainExplorer;
+    function get(platform: TPlatform | number): any;
+    function get(config: TExplorerDefinition): any;
+    /** @obsolete */
+    function get(platform: TPlatform | number, opts: IBlockchainExplorerFactoryParams): any;
     /** Same as sync variation, but ensures the config is being fetched */
-    function getAsync(platform: TPlatform | string, opts?: IBlockchainExplorerFactoryParams): Promise<IBlockchainExplorer | BlockchainExplorer>;
+    function getAsync(platform: TPlatform, opts?: IBlockchainExplorerFactoryParams): Promise<any>;
     /** @obsolete Create instance directly with the get/getAsync method */
     function create(opts: IBlockchainExplorerFactoryParams): Constructor<IBlockchainExplorer>;
 }

package/lib/types/explorer/verifiers/FsHtmlVerifier.d.ts

@@ -2,13 +2,13 @@ import { TEth } from '../../models/TEth';
 import { IVerifier } from './IVerifier';
 import { IBlockchainTransferEvent } from '../IBlockchainExplorer';
 import { TPlatform } from '../../models/TPlatform';
-import { IBlockchainExplorerConfig } from '../BlockchainExplorer';
+import { TExplorer } from '../../models/TExplorer';
 export declare class FsHtmlVerifier implements IVerifier {
     platform: TPlatform;
-    config: IBlockchainExplorerConfig;
+    config: TExplorer;
     private key;
     private enabled;
-    constructor(platform: TPlatform, config: IBlockchainExplorerConfig);
+    constructor(platform: TPlatform, config: TExplorer);
     submitContractVerification(contractData: {
         address: `0x${string}`;
         sourceCode: any;

package/lib/types/json/JsonArrayMultiStore.d.ts

@@ -1,9 +1,9 @@
 /**
  * Store data across multiple files for cases, that could contain thousands of entries
  */
-import { IStoreOptions } from './JsonArrayStore';
+import { IArrayStoreOptions } from './JsonArrayStore';
 import type { Alot } from 'alot/alot';
-export interface IMultiStoreOptions<T> extends IStoreOptions<T> {
+export interface IMultiStoreOptions<T> extends IArrayStoreOptions<T> {
     groupKey: (x: T) => number;
     groupSize: number;
 }

package/lib/types/json/JsonArrayStore.d.ts

@@ -1,6 +1,6 @@
 import { Alot } from 'alot/alot';
 import { Constructor } from '../utils/types';
-export interface IStoreOptions<T, TStorage = T> {
+export interface IArrayStoreOptions<T, TStorage = T> {
     path: string;
     watchFs?: boolean;
     onFsChanged?: () => any;
@@ -9,13 +9,14 @@ export interface IStoreOptions<T, TStorage = T> {
     serialize?(x: T): TStorage;
     Type?: Constructor;
     format?: boolean;
+    transport?: 'file' | 'localStorage';
 }
 export declare class JsonArrayStore<T> {
-    options: IStoreOptions<T>;
+    options: IArrayStoreOptions<T>;
     private array;
     private hash;
     private fs;
-    constructor(options: IStoreOptions<T>);
+    constructor(options: IArrayStoreOptions<T>);
     query(): Promise<Alot<T>>;
     getAll(opts?: {
         cloned?: boolean;

package/lib/types/json/JsonObjectStore.d.ts

@@ -1,5 +1,5 @@
 import type { Constructor } from 'atma-utils';
-export interface IStoreOptions<T, TOut = T> {
+export interface IObjectStoreOptions<T, TOut = T> {
     path: string;
     map?(x: T): TOut;
     serialize?(x: T): any;
@@ -7,12 +7,14 @@ export interface IStoreOptions<T, TOut = T> {
     format?: boolean;
     default?: TOut;
     watchFs?: boolean;
+    onFsChanged?: () => any;
+    transport?: 'file' | 'localStorage';
 }
 export declare class JsonObjectStore<T> {
-    options: IStoreOptions<T>;
+    options: IObjectStoreOptions<T>;
     private data;
     private fs;
-    constructor(options: IStoreOptions<T>);
+    constructor(options: IObjectStoreOptions<T>);
     get(opts?: {
         cloned?: boolean;
     }): Promise<this['options']['default']>;

package/lib/types/json/JsonStoreFs.d.ts

@@ -6,6 +6,7 @@ export declare class JsonStoreFs<T> {
     format?: boolean;
     $default?: T;
     serializeFn?: (x: T) => any;
+    persistence: 'file' | 'localStorage';
     errored: Error;
     private listeners;
     private version;
@@ -14,9 +15,9 @@ export declare class JsonStoreFs<T> {
     private busy;
     private watcherFn;
     private watching;
-    private file;
+    private transport;
     lock: class_Dfr<any>;
-    constructor(path: string, Type?: Constructor, mapFn?: (x: T) => any, format?: boolean, $default?: T, serializeFn?: (x: T) => any);
+    constructor(path: string, Type?: Constructor, mapFn?: (x: T) => any, format?: boolean, $default?: T, serializeFn?: (x: T) => any, persistence?: 'file' | 'localStorage');
     watch(cb: typeof this.watcherFn): void;
     unwatch(): void;
     cleanCache(): void;

package/lib/types/models/TAccount.d.ts

@@ -1,3 +1,4 @@
+import type { RpcTypes } from '../rpc/Rpc';
 import { TAddress } from './TAddress';
 import { TEth } from './TEth';
 import { TPlatform } from './TPlatform';
@@ -14,6 +15,13 @@ export interface IAccountTx extends IAccount {
 export interface EoAccount extends IAccount {
     type?: 'eoa';
     key?: TEth.Hex | `p1:0x${string}`;
+    signer?: IRpcSigner;
+}
+interface 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>;
 }
 export interface SafeAccount extends IAccount {
     type: 'safe';
@@ -34,3 +42,4 @@ export interface Erc4337Account extends IAccount {
     operator: EoAccount;
 }
 export type TAccount = string | IAccount | EoAccount | SafeAccount | Erc4337Account;
+export {};

package/lib/types/models/TChain.d.ts

@@ -0,0 +1,45 @@
+import { IRpcConfig } from '../clients/ClientPool';
+import { TEth } from './TEth';
+import { IToken } from './IToken';
+import { TExplorer } from './TExplorer';
+export interface TChain {
+    name?: string;
+    icon?: string;
+    wwww?: string;
+    platform: TEth.Platform;
+    aliases?: string[];
+    chainId?: number;
+    chainToken?: string;
+    endpoints: IRpcConfig[];
+    explorers: TExplorer[];
+    tokens?: IToken[];
+    defaultTxType?: 0 | 1 | 2;
+    defaultGasPriceRatio?: number;
+    blockTimeAvg?: number;
+    erc4337?: {
+        name: string;
+        contracts: {
+            entryPoint: TEth.Address;
+            accountFactory: TEth.Address;
+        };
+    }[];
+    safe?: {
+        transactionService: `https://${string}`;
+        contracts: {
+            Safe: TEth.Address;
+            SafeL2?: TEth.Address;
+            SafeProxyFactory: TEth.Address;
+            MultiSend: TEth.Address;
+            CreateCall?: TEth.Address;
+        };
+    };
+    flashbots?: {
+        url: string;
+    };
+    spotPriceAggregator?: {
+        aggregator: TEth.Address;
+    };
+    ens?: {
+        registry: TEth.Address;
+    };
+}

package/lib/types/models/TEth.d.ts

@@ -1,3 +1,4 @@
+import type { RpcTypes } from '../rpc/Rpc';
 import { TPlatform } from './TPlatform';
 export declare namespace TEth {
     type Hex = `0x${string}`;
@@ -114,6 +115,13 @@ export declare namespace TEth {
     interface EoAccount extends IAccount {
         type?: 'eoa';
         key?: TEth.Hex | `p1:0x${string}`;
+        signer?: IRpcSigner;
+    }
+    interface 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>;
     }
     interface SafeAccount extends IAccount {
         type: 'safe';

package/lib/types/models/TExplorer.d.ts

@@ -0,0 +1,31 @@
+import { Web3Client } from '../clients/Web3Client';
+import { IContractDetails } from './IContractDetails';
+import { TEth } from './TEth';
+/** Blockchain explorer settings - in config */
+export interface TExplorerDefinition {
+    platform: TEth.Platform;
+    name?: string;
+    standard?: 'EIP3091' | string;
+    url?: string;
+    key?: string;
+    api?: string | {
+        url?: string;
+        key?: string;
+    };
+    verification?: boolean | 'fs';
+    ABI_CACHE?: string;
+    CONTRACTS?: IContractDetails[];
+    getWeb3?: (platform?: TEth.Platform) => Web3Client;
+}
+/** Blockchain explorer settings - normalized */
+export interface TExplorer {
+    platform: TEth.Platform;
+    name: string;
+    standard: 'EIP3091' | string;
+    url: string;
+    api: {
+        url: string;
+        key?: string;
+    };
+    verification: boolean | 'fs';
+}

package/lib/types/rpc/transports/ITransport.d.ts

@@ -1,6 +1,7 @@
 import type { IWeb3EndpointOptions } from '../../clients/interfaces/IWeb3EndpointOptions';
 import type { TEth } from '../../models/TEth';
 import type { ClientOptions } from 'ws';
+import { IEip1193Provider } from './compatibility/EIP1193Transport';
 export declare namespace TTransport {
     type Transport = {
         id?: string;
@@ -37,7 +38,7 @@ export declare namespace TTransport {
         subscribe(cb: (x: T) => void, onError?: (x: Error | any) => void, once?: any): any;
     }
     namespace Options {
-        type Any = string | Http | Ws | Wrapped | Transport | Web3Wrapper;
+        type Any = string | Http | Ws | Wrapped | Transport | Web3Wrapper | IEip1193Provider;
         type Http = {
             url: string;
         } & Omit<Parameters<typeof fetch>[1], 'headers'> & {

package/lib/types/rpc/transports/compatibility/EIP1193Transport.d.ts

@@ -1,7 +1,11 @@
 import { TTransport } from '../ITransport';
 import { RpcSubscription } from '../../RpcSubscription';
 export interface IEip1193Provider {
-    sendAsync: any;
+    sendAsync?(request: Object, callback: Function): void;
+    request(args: {
+        method: string;
+        params?: any[];
+    }): Promise<unknown>;
 }
 export declare class EIP1193Transport implements TTransport.Transport {
     private provider;

package/lib/types/rpc/transports/compatibility/IEIP6963Provider.d.ts

@@ -0,0 +1,21 @@
+export interface IEIP6963Provider {
+    isStatus?: boolean;
+    request: (request: {
+        method: string;
+        params?: Array<any>;
+    }) => Promise<any>;
+    on(event: 'accountsChanged', handler: (accounts: Array<string>) => void): any;
+    on(event: 'chainChanged', handler: (chainId: string) => void): any;
+    on(event: 'connect', handler: (connectInfo: ConnectInfo) => void): any;
+    on(event: 'disconnect', handler: (error: ProviderRpcError) => void): any;
+    removeListener(event: 'accountsChanged' | 'chainChanged' | 'connect' | 'disconnect', handler: (...args: any[]) => void): any;
+}
+interface ConnectInfo {
+    chainId: string;
+}
+interface ProviderRpcError extends Error {
+    message: string;
+    code: number;
+    data?: unknown;
+}
+export {};

package/lib/types/utils/$config.d.ts

@@ -1,5 +1,10 @@
+import { TEth } from '../models/TEth';
+import { IWeb3ClientOptions } from '../clients/interfaces/IWeb3Client';
+import { TExplorerDefinition } from '../models/TExplorer';
 export declare namespace $config {
     function get<T = any>(path: string, $default?: T): T;
+    function getWeb3Options(mix: TEth.Platform | number): IWeb3ClientOptions;
+    function getExplorerOptions(mix: TEth.Platform | number): TExplorerDefinition;
     function set<T = any>(path: string, value: T): void;
     /**
      * Reloads dequanto env config from cli ARGUMENTS and DQ_SETTINGS__** environment

package/lib/types/utils/$ref.d.ts

@@ -0,0 +1,11 @@
+import { IEIP6963Provider } from '../rpc/transports/compatibility/IEIP6963Provider';
+export type TGlobal = {
+    ethereum: IEIP6963Provider;
+    addEventListener: Window['addEventListener'];
+    removeEventListener: Window['removeEventListener'];
+    dispatchEvent(event: any): void;
+    localStorage?: WindowLocalStorage['localStorage'];
+};
+export declare namespace $ref {
+    function getGlobal(): TGlobal;
+}

package/lib/types/utils/$secret.d.ts

@@ -1,5 +1,6 @@
 export declare namespace $secret {
     function getPin(parameters?: {
         pin?: string;
+        machineKey?: string;
     }): Promise<string>;
 }

package/lib/types/utils/$sig.d.ts

@@ -21,6 +21,7 @@ export declare namespace $sig {
     }): TEth.Address;
     function recoverTx(signedTxRaw: TEth.Hex): `0x${string}`;
     namespace $rpc {
+        function ensureRpcSigner(account: TEth.EoAccount, mix: Rpc | Web3Client): Promise<Rpc>;
         function signTx(rpc: Rpc, tx: TEth.TxLike): Promise<TEth.Hex>;
         function signTypedData(rpc: Rpc, typedData: Partial<RpcTypes.TypedData>, account: TEth.EoAccount): Promise<TSignature>;
         function sign(rpc: Rpc, message: string | Uint8Array, account: TEth.EoAccount): Promise<TSignature>;