dequanto 0.1.39 → 0.1.45

package/src/json/JsonStoreFs.ts

@@ -3,6 +3,7 @@ import { $require } from '@dequanto/utils/$require';
 import { File, FileSafe } from 'atma-io';
 import { class_Dfr, type Constructor } from 'atma-utils';
 import { JsonConvert } from 'class-json';
+import { $ref } from '@dequanto/utils/$ref';
 
 
 export class JsonStoreFs<T> {
@@ -15,7 +16,7 @@ export class JsonStoreFs<T> {
     private busy = false;
     private watcherFn: (path?: string) => any
     private watching = false;
-    private file: InstanceType<typeof File>;
+    private transport: ITransport;
 
     public lock = new class_Dfr;
 
@@ -26,15 +27,19 @@ export class JsonStoreFs<T> {
         , public format?: boolean
         , public $default?: T
         , public serializeFn?: (x: T) => any
+        , public persistence: 'file' | 'localStorage' = 'file'
     ) {
         this.lock.resolve();
 
-        const FileCtor = FileSafe ?? File;
-        this.file = new FileCtor(this.path, {
-            cached: false,
-            processSafe: true,
-            threadSafe: true,
-        });
+        switch (persistence) {
+            case 'localStorage':
+                this.transport = new LocalStorageTransport(this.path);
+                break;
+            case 'file':
+            default:
+                this.transport = new FileTransport(this.path);
+                break;
+        }
     }
 
     public watch (cb: typeof this.watcherFn) {
@@ -42,14 +47,13 @@ export class JsonStoreFs<T> {
         this.watcherFn = cb;
     }
     public unwatch () {
-        File.unwatch(this.path, this.watcherFn);
+        this.transport.unwatch(this.watcherFn);
         this.watcherFn = null;
     }
     public cleanCache () {
         this.data = null;
         // Should we do this? clear pending promise
-        (this.file as any).pending = null;
-        this.file.content = null;
+        this.transport.cleanCache();
 
         memd.fn.clearMemoized(this.readInner);
         File.clearCache(this.path);
@@ -89,21 +93,17 @@ export class JsonStoreFs<T> {
 
     @memd.deco.memoize({ perInstance: true })
     private async readInner () {
-        let exists = await File.existsAsync (this.path);
+        let exists = await this.transport.exists();
         if (exists === false) {
             return this.$default;
         }
-        let str = await this.file.readAsync <string> ({
-            skipHooks: true,
-            encoding: 'utf8',
-            cached: false
-        });
+        let str = await this.transport.readAsync();
         if (str == null) {
             return this.$default;
         }
         let data = this.decode(str);
         if (this.watcherFn != null && this.watching === false) {
-            File.watch(this.path, this.watcherFn);
+            this.transport.watch(this.watcherFn);
             this.watching = true;
         }
         return data;
@@ -113,7 +113,7 @@ export class JsonStoreFs<T> {
         let v = this.version;
         let str = this.encode(data);
         try {
-            await this.file.writeAsync(str, { skipHooks: true });
+            await this.transport.writeAsync(str);
             this.lock.resolve();
             this.callWriteListeners(v, null);
         } catch (error) {
@@ -186,3 +186,88 @@ export class JsonStoreFs<T> {
         return JSON.stringify(data, null, format ? '  ' : null)
     }
 }
+
+interface ITransport {
+    writeAsync(str: string): Promise<void>
+    readAsync(): Promise<string>
+
+    watch (watcherFn: (path?: string) => any)
+    unwatch (watcherFn: (path?: string) => any)
+
+    cleanCache()
+    exists (): Promise<boolean>
+}
+
+class FileTransport implements ITransport {
+    private file: InstanceType<typeof File>;
+
+    constructor (public path: string) {
+        const FileCtor = FileSafe ?? File
+        this.file = new FileCtor(this.path, {
+            cached: false,
+            processSafe: true,
+            threadSafe: true,
+        });
+    }
+    async exists(): Promise<boolean> {
+        return File.existsAsync (this.path);
+    }
+    async writeAsync(str: string) {
+        await this.file.writeAsync(str, { skipHooks: true });
+    }
+    async readAsync(): Promise<string> {
+        let str = await this.file.readAsync <string> ({
+            skipHooks: true,
+            encoding: 'utf8',
+            cached: false
+        });
+        return str;
+    }
+    async watch (watcherFn: (path?: string) => any) {
+        File.watch(this.path, watcherFn);
+    }
+    async unwatch (watcherFn: (path?: string) => any) {
+        File.unwatch(this.path, watcherFn);
+    }
+
+    async cleanCache () {
+        (this.file as any).pending = null;
+        this.file.content = null;
+    }
+}
+
+
+
+class LocalStorageTransport implements ITransport {
+    private global = $ref.getGlobal();
+    private listener: (event) => void;
+
+    constructor (public path: string) {
+        $require.notNull(this.global.localStorage, `LocalStorage is not available`);
+    }
+    async writeAsync(str: string) {
+        this.global.localStorage.setItem(this.path, str);
+    }
+    async readAsync(): Promise<string> {
+        return this.global.localStorage.getItem(this.path);
+    }
+    async exists (): Promise<boolean> {
+        // To prevent double load with "getItem", assume the existence of the item, later in readAsync the NULL will be handled.
+        return true;
+    }
+    async watch (watcherFn: (path?: string) => any) {
+        this.listener ??= (event) => {
+            if (event.key === this.path) {
+                watcherFn(this.path);
+            }
+        };
+        this.global.addEventListener('storage', this.listener, false);
+    }
+    async unwatch (watcherFn: (path?: string) => any) {
+        this.global.removeEventListener('storage', this.listener, false);
+    }
+
+    async cleanCache () {
+        // no cached
+    }
+}

package/src/models/TAccount.ts

@@ -1,8 +1,8 @@
+import type { RpcTypes } from '@dequanto/rpc/Rpc'
 import { TAddress } from './TAddress';
 import { TEth } from './TEth';
 import { TPlatform } from './TPlatform';
 
-
 export interface IAccount {
     type?: 'eoa' | 'safe' | 'erc4337'
     name?: string
@@ -19,7 +19,15 @@ export interface IAccountTx extends IAccount {
 
 export interface EoAccount extends IAccount {
     type?: 'eoa'
-    key?: TEth.Hex | `p1:0x${string}`;
+    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 {

package/src/models/TChain.ts

@@ -0,0 +1,56 @@
+import { IRpcConfig } from '@dequanto/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;
+
+    // block time in ms
+    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/src/models/TEth.ts

@@ -1,3 +1,4 @@
+import type { RpcTypes } from '@dequanto/rpc/Rpc'
 import { TPlatform } from './TPlatform'
 
 export namespace TEth {
@@ -143,6 +144,14 @@ export namespace TEth {
     export interface EoAccount extends IAccount {
         type?: 'eoa'
         key?: TEth.Hex | `p1:0x${string}`;
+        signer?: IRpcSigner
+    }
+
+    export 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 {
@@ -215,9 +224,6 @@ export namespace TEth {
             internalType?: string;
         }
     }
-
-
-
 }
 
 

package/src/models/TExplorer.ts

@@ -0,0 +1,35 @@
+import { Web3Client } from '@dequanto/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/src/models/TPlatform.ts

@@ -1,6 +1,7 @@
 // https://github.com/ethereum-lists/chains
 // https://chainid.network/chains.json
 // https://github.com/DefiLlama/chainlist/blob/main/constants/extraRpcs.js
+// https://api.llama.fi/chains
 
 // https://eips.ethereum.org/EIPS/eip-3770
 export type TPlatform = 'eth'

package/src/rpc/transports/ITransport.ts

@@ -1,6 +1,7 @@
 import type { IWeb3EndpointOptions } from '@dequanto/clients/interfaces/IWeb3EndpointOptions';
 import type { TEth } from '@dequanto/models/TEth';
 import type { ClientOptions } from 'ws'
+import { IEip1193Provider } from './compatibility/EIP1193Transport';
 
 export namespace TTransport {
 
@@ -39,7 +40,7 @@ export namespace TTransport {
 
     export namespace Options {
 
-        export type Any = string | Http | Ws | Wrapped | Transport | Web3Wrapper;
+        export type Any = string | Http | Ws | Wrapped | Transport | Web3Wrapper | IEip1193Provider;
 
         export type Http = {
             url: string

package/src/rpc/transports/RpcTransport.ts

@@ -51,7 +51,11 @@ export namespace RpcTransport {
             if (isEIP1193Compatible(mix.web3)) {
                 return new EIP1193Transport(mix.web3);
             }
+            if (isTransport(mix.web3)) {
+                return mix.web3;
+            }
         }
+        console.error(mix);
         throw new Error(`Unknown transport: ${JSON.stringify(mix)}`);
     }
 

package/src/rpc/transports/compatibility/EIP1193Transport.ts

@@ -4,7 +4,11 @@ import { RpcSubscription } from '@dequanto/rpc/RpcSubscription';
 import alot from 'alot';
 
 export interface IEip1193Provider {
-    sendAsync
+    sendAsync? (request: Object, callback: Function): void;
+    request (args: {
+        method: string;
+        params?: any[];
+      }): Promise<unknown>;
 }
 
 
@@ -22,9 +26,20 @@ export class EIP1193Transport implements TTransport.Transport {
                 return this.request(x);
             }).toArrayAsync({ threads: 5 });
         }
-
-        let result = await $promise.fromCallbackCtx(this.provider, this.provider.sendAsync, req);
-        return result;
+        if (typeof this.provider.sendAsync === 'function') {
+            let result = await $promise.fromCallbackCtx(this.provider, this.provider.sendAsync, req);
+            return result;
+        }
+        if (typeof this.provider.request === 'function') {
+            let result = await this.provider.request(req);
+            // Normalize response to EIP-1193 format
+            return {
+                id: req.id,
+                jsonrpc: '2.0',
+                result
+            };
+        }
+        throw new Error(`Invalid transport with no sendAsync, request methods`);
     }
 
     async subscribe(req: TTransport.Request): Promise<TTransport.Subscription<any>> {
@@ -33,6 +48,4 @@ export class EIP1193Transport implements TTransport.Transport {
     unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [number]; }): Promise<RpcSubscription<any>> {
         throw new Error('Method not implemented.');
     }
-
-
 }

package/src/rpc/transports/compatibility/IEIP6963Provider.ts

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

package/src/safe/GnosisSafeHandler.ts

@@ -69,6 +69,7 @@ export class GnosisSafeHandler {
 
     async submitTransaction(safeTxHash: string, options?: { threshold?: number }) {
         let tx = await this.transport.getTx(safeTxHash);
+
         let writer = di.resolve(ContractWriter, this.safeAddress, this.client);
         let confirmations = tx.confirmations;
 
@@ -213,7 +214,6 @@ export class GnosisSafeHandler {
             let {
                 signature,
             } = await this.createTxSignature(safeTxHash, owner);
-
             return {
                 address: owner.address.toLowerCase(),
                 signature: signature

package/src/tokens/TokenProviders/TPChain.ts

@@ -4,6 +4,7 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { TPlatform } from '@dequanto/models/TPlatform';
 import { ITokenProvider } from './ITokenProvider';
 import { ContractReader } from '@dequanto/contracts/ContractReader';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
 
 export class TPChain implements ITokenProvider {
 
@@ -12,9 +13,12 @@ export class TPChain implements ITokenProvider {
     }
 
     async getByAddress(platform: TPlatform, address: TAddress) {
-        if (this.platform !== platform) {
+        if (this.platform !== platform || platform === 'hardhat') {
             return null;
         }
+        if (this.client == null) {
+            this.client = await Web3ClientFactory.getAsync(platform);
+        }
 
         let reader = new ContractReader(this.client)
         try {

package/src/txs/TxWriter.ts

@@ -173,8 +173,15 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
 
         let agent = TxWriterAccountAgents.get(this.account);
         if (agent != null) {
+
             let sender = await this.getSender();
-            let innerWriter = await agent.process(sender, this.account, this);
+            let innerWriter: TxWriter;
+            try {
+                innerWriter = await agent.process(sender, this.account, this);
+            } catch (error) {
+                this.onCompleted.reject(error);
+                return;
+            }
             this.pipeInnerWriter(innerWriter);
             return;
         }
@@ -242,7 +249,6 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                 .client
                 .sendTransaction(txData);
         }
-
         promiseEvent
             .once('transactionHash', hash => {
                 if (tx.hash === hash) {

package/src/utils/$buffer.ts

@@ -109,7 +109,7 @@ class NodeBufferUtils extends BufferBase {
         if (buffer instanceof Buffer) {
             return (`0x` + buffer.toString('hex')) as TEth.Hex;
         }
-        return (`0x` + buffer.reduce((hex, x) => {
+        return (`0x` + (buffer as Uint8Array).reduce((hex, x) => {
             return hex + x.toString(16).padStart(2, '0');
         }, '')) as TEth.Hex;
     }

package/src/utils/$config.ts

@@ -1,6 +1,12 @@
+import alot from 'alot';
+import { obj_getProperty, obj_setProperty } from 'atma-utils';
 import { config } from '@dequanto/config/Config';
 import { ConfigDefaults } from '@dequanto/config/ConfigDefaults';
-import { obj_getProperty, obj_setProperty } from 'atma-utils';
+import { IConfigData } from '@dequanto/config/interface/IConfigData';
+import { TEth } from '@dequanto/models/TEth';
+import { $require } from './$require';
+import { IWeb3ClientOptions } from '@dequanto/clients/interfaces/IWeb3Client';
+import { TExplorerDefinition } from '@dequanto/models/TExplorer';
 
 const $global = typeof global === 'undefined'
     ? window
@@ -24,8 +30,73 @@ export namespace $config {
         return value ?? $default;
     }
 
+    export function getWeb3Options (mix: TEth.Platform | number): IWeb3ClientOptions {
+        let web3 = $config.get<IConfigData['web3']>('web3');
+        let chains = $config.get<IConfigData['chains']>('chains', []);
+        let platform: TEth.Platform;
+        if (typeof mix === 'number') {
+            let chain = alot.fromObject(web3).find(x => x.value.chainId === mix);
+            if (chain != null) {
+                platform = chain.key;
+            } else {
+                let chain = chains.find(x => x.chainId === mix);
+                if (chain!= null) {
+                    platform = chain.platform;
+                }
+            }
+            $require.notNull(platform, `Invalid platform for chainId ${mix}`);
+        } else {
+            platform = mix;
+        }
+        if (platform.startsWith('hh:')) {
+            // Hardhat fork
+            return { platform } as any;
+        }
+
+        let web3Config = web3[platform];
+        if (web3Config == null) {
+            // Find the configuration by the alias
+            let chain = alot
+                .fromObject(web3)
+                .filter(x => Array.isArray(x.value.aliases))
+                .find(x => x.value.aliases.includes(platform));
+            web3Config = chain?.value;
+        }
+
+        let chainConfig = chains.find(x => x.platform === platform || x.aliases?.includes(platform));
+
+        $require.notNull(web3Config || chainConfig, `Unsupported platform ${platform} for web3 client`);
+        return {
+            platform,
+            ...(chainConfig ?? {}),
+            ...(web3Config ?? {}),
+        } as any as IWeb3ClientOptions;
+    }
+
+    export function getExplorerOptions (mix: TEth.Platform | number): TExplorerDefinition {
+        let platform = getWeb3Options(mix).platform;
+
+        let explorer = $config.get<IConfigData['blockchainExplorer']>(`blockchainExplorer`);
+        let chains = $config.get<IConfigData['chains']>('chains', []);
+
+
+        let explorerConfig = explorer[platform];
+        let chainConfig = chains.find(x => x.platform === platform || x.aliases?.includes(platform));
+
+        $require.notNull(explorerConfig || chainConfig, `Unsupported platform ${platform} for web3 client`);
+        return {
+            platform,
+            ...(chainConfig?.explorers?.[0] ?? {}),
+            ...(explorerConfig ?? {}),
+        } satisfies TExplorerDefinition;
+    }
+
     export function set <T = any> (path: string, value: T) {
-        $global.app.config?.$set?.(path, value);
+        if (typeof $global.app?.config?.$set === 'function') {
+            $global.app.config.$set(path, value);
+            return;
+        }
+        obj_setProperty(config, path, value);
     }
 
     /**

package/src/utils/$dependency.ts

@@ -1,5 +1,7 @@
 /** ESM and CJS Loader */
 
+import { $is } from './$is';
+
 export namespace $dependency {
 
     export async function load<T = any> (name: string): Promise<T> {
@@ -16,6 +18,9 @@ export namespace $dependency {
     }
 
     export function dirname () {
+        if ($is.BROWSER) {
+            return location.origin;
+        }
         if (typeof __dirname !== 'undefined') {
             return __dirname;
         }

package/src/utils/$path.ts

@@ -2,6 +2,7 @@ import { class_Uri } from 'atma-utils';
 import { $config } from './$config';
 import { env } from 'atma-io';
 import { $dependency } from './$dependency';
+import { $is } from './$is';
 
 export namespace $path {
     let root: string = null;
@@ -76,6 +77,14 @@ export namespace $path {
 
     function getRoot () {
         let base = $config.get('settings.base');
+        if ($is.BROWSER) {
+            let root = $dependency.dirname();
+            if (base != null && isAbsolute(base)) {
+                return base;
+            }
+            base ??= '/node_modules/dequanto/';
+            return class_Uri.combine(root, base);
+        }
         if (base != null) {
             let cwd = process.cwd();
             return class_Uri.combine('file://' + cwd, base);

package/src/utils/$ref.ts

@@ -0,0 +1,40 @@
+
+import { IEIP6963Provider } from '@dequanto/rpc/transports/compatibility/IEIP6963Provider';
+import { class_EventEmitter } from 'atma-utils';
+
+
+
+export type TGlobal = {
+    ethereum: IEIP6963Provider;
+    addEventListener: Window['addEventListener'] //(event: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener: Window['removeEventListener'];
+
+    dispatchEvent (event: any): void;
+
+    localStorage?: WindowLocalStorage['localStorage']
+}
+
+export namespace $ref {
+    export function getGlobal (): TGlobal {
+        if (typeof window !== 'undefined' && typeof window === 'object') {
+            const g = window as any as TGlobal;
+            return g;
+        }
+        if (typeof global !== 'undefined' && typeof global  === 'object') {
+            const g = global as any as TGlobal;
+
+            if (typeof g.addEventListener !== 'function' || typeof g.dispatchEvent !== 'function') {
+                const emitter = new class_EventEmitter;
+                g.addEventListener = function (event: string, fn: (event) => any) {
+                    emitter.on(event, fn);
+                };
+                g.dispatchEvent = function (event: CustomEvent) {
+                    emitter.emit(event.type, event);
+                };
+            }
+
+            return g;
+        }
+        throw new Error('No global object found');
+    }
+}