dequanto 0.0.1 → 0.0.7

package/src/clients/debug/ClientDebugMethods.ts

@@ -0,0 +1,75 @@
+import alot from 'alot'
+import { TAddress } from '@dequanto/models/TAddress'
+import { TBufferLike } from '@dequanto/models/TBufferLike'
+import type { IWeb3ClientOptions } from '../interfaces/IWeb3Client';
+import type { Web3Client } from '../Web3Client';
+
+
+export class ClientDebugMethods {
+
+    constructor (public client: Web3Client, public methods: IWeb3ClientOptions['debug'] ) {
+
+    }
+
+    getTransactionTrace (hash: string) {
+        return this.client.pool.call(async web3 => {
+            let eth = web3.eth as (typeof web3.eth & { traceTransaction });
+
+            if (typeof eth.traceTransaction !== 'function') {
+                web3.eth.extend({
+                    methods: [
+                        {
+                            name: 'traceTransaction',
+                            call: 'debug_traceTransaction',
+                            params: 2,
+                        }
+                    ]
+                })
+            }
+
+            let result = await eth.traceTransaction(hash, {
+                tracer: 'callTracer'
+            });
+            return result;
+
+        }, {
+            node: {
+                traceable: true
+            }
+        });
+    }
+
+    setStorageAt (address: TAddress, location: string | number | bigint, buffer: TBufferLike) {
+        return this.call('setStorageAt', ...arguments);
+    }
+
+    setCode (address: TAddress, buffer: TBufferLike) {
+        return this.call('setCode', ...arguments);
+    }
+
+    setBalance (address: TAddress, amount: bigint) {
+        return this.call('setBalance', ...arguments);
+    }
+
+    private call(method: keyof typeof this.methods, ...args: any[]) {
+        let meta = this.methods[method];
+        if (meta?.call == null) {
+            throw new Error(`RPC method for ${method} is not configurated in ${this.client.platform}`);
+        }
+        return this.client.pool.call(web3 => {
+            let eth = web3.eth as (typeof web3.eth & { [key in typeof method]: Function });
+            if (eth[method] == null) {
+                web3.eth.extend({
+                    methods: [
+                        {
+                            name: method,
+                            call: meta.call,
+                            params: meta.params,
+                        }
+                    ]
+                });
+            }
+            return eth[method](...args);
+        })
+    }
+}

package/src/clients/interfaces/IWeb3Client.ts

@@ -1,14 +1,42 @@
-import { TxData } from '@ethereumjs/tx';
-import Web3 from 'web3';
+import { TBufferLike } from '@dequanto/models/TBufferLike';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TransactionRequest } from '@ethersproject/abstract-provider';
+
+import type Web3 from 'web3';
+import { provider } from 'web3-core';
+import { IPoolClientConfig } from '../ClientPool';
 
 export interface IWeb3Client {
     platform: string
     chainId: number
     defaultGasLimit: number
 
-    // web3: Web3
-    // eth: Web3['eth']
+    sign (txData: TransactionRequest, privateKey: string): Promise<TBufferLike>
+}
+
 
+export interface IWeb3ClientOptions {
+    endpoints: IPoolClientConfig[]
+    platform?: TPlatform
+    chainId?: number
+    // Token symbol: e.g. ETH
+    chainToken?: string
+    // alias to `provider`
+    web3?: Web3 | provider
+    provider?: Web3 | provider
 
-    sign (txData: TxData, privateKey: string): Buffer
+    debug?: {
+        setStorageAt?: {
+            call: 'hardhat_setStorageAt' | string
+            params: 3 | number
+        },
+        setCode?: {
+            call: 'hardhat_setCode' | string
+            params: 2 | number
+        },
+        setBalance?: {
+            call: 'hardhat_setBalance' | string,
+            params: 2 | number
+        }
+    }
 }

package/src/clients/interfaces/IWeb3EndpointOptions.ts

@@ -1,4 +1,6 @@
 import { Config } from '@dequanto/Config';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import type Web3 from 'web3';
 
 export interface IWeb3EndpointOptions {
     type?: 'private'
@@ -6,4 +8,8 @@ export interface IWeb3EndpointOptions {
     ws?: boolean
 
     endpoints?: Config['web3']['eth']['endpoints']
+    web3?: Web3
+    platform?: TPlatform
+    chainId?: number
+    chainToken?: string
 }

package/src/clients/utils/ClientEndpoints.ts

@@ -3,12 +3,18 @@ import { IWeb3EndpointOptions } from '../interfaces/IWeb3EndpointOptions';
 export namespace ClientEndpoints {
 
     export function filterEndpoints (endpoints, opts: IWeb3EndpointOptions) {
+        if (opts?.web3) {
+            return [];
+        }
         if (opts?.endpoints) {
             endpoints = opts.endpoints
         }
         if (opts == null) {
             return endpoints;
         }
+        if (endpoints == null) {
+            return null;
+        }
         return endpoints.filter(endpoint => {
             if (opts.type != null && endpoint.type !== opts.type) {
                 return false;

package/src/clients/utils/TxFactory.ts

@@ -1,17 +1,17 @@
-import {
-    FeeMarketEIP1559Transaction,
-    Transaction,
-    TxData,
-    FeeMarketEIP1559TxData,
-    TxOptions
-} from '@ethereumjs/tx';
+// import {
+//     FeeMarketEIP1559Transaction,
+//     Transaction,
+//     TxData,
+//     FeeMarketEIP1559TxData,
+//     TxOptions
+// } from '@ethereumjs/tx';
 
 export namespace TxFactory {
-    export function fromTxData (txData: TxData | FeeMarketEIP1559TxData, opts?: TxOptions) {
-        const Factory = txData.type && Number(txData.type) === 2
-            ? FeeMarketEIP1559Transaction
-            : Transaction
+    // export function fromTxData (txData: TxData | FeeMarketEIP1559TxData, opts?: TxOptions) {
+    //     const Factory = txData.type && Number(txData.type) === 2
+    //         ? FeeMarketEIP1559Transaction
+    //         : Transaction
 
-        return Factory.fromTxData(txData as any, opts);
-    }
+    //     return Factory.fromTxData(txData as any, opts);
+    // }
 }

package/src/contracts/Contract.ts

@@ -12,7 +12,8 @@ import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder'
 import { TxWriter } from '@dequanto/txs/TxWriter'
 import { Web3Client } from '@dequanto/clients/Web3Client'
 import { $contract } from '@dequanto/utils/$contract'
-import { ChainAccount } from '@dequanto/ChainAccounts'
+import { ChainAccount } from "@dequanto/models/TAccount"
+import { $is } from '@dequanto/utils/$is'
 
 export interface IContractInit {
     Ctor?:  new (...args) => any
@@ -111,7 +112,7 @@ export abstract class Contract {
 
         let info = await provider.getInfo(mix)
         if (info == null) {
-            let byName = mix.startsWith('0x') === false;
+            let byName = $is.Address(mix) === false;
             if (byName) {
                 throw new Error(`Contract by name not found ${mix}`);
             }

package/src/contracts/ContractAbiProvider.ts

@@ -0,0 +1,68 @@
+import { type AbiItem } from 'web3-utils';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { $address } from '@dequanto/utils/$address';
+import { $require } from '@dequanto/utils/$require';
+
+import { TAddress } from '@dequanto/models/TAddress';
+import { File } from 'atma-io';
+import { class_Uri } from 'atma-utils';
+import { $path } from '@dequanto/utils/$path';
+import { $logger } from '@dequanto/utils/$logger';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+
+
+export class ContractAbiProvider {
+
+    constructor (public client: Web3Client, public explorer: IBlockChainExplorer) {
+
+    }
+
+    async getAbi(abi: TAddress | string, opts: { implementation?: string, location?: string } = null) {
+
+        $require.notNull(abi, `Abi not provided to get the Abi Json from`);
+
+        let abiJson: AbiItem[]
+        let implementation: TAddress;
+        if (abi.startsWith('0x')) {
+            let { abi: abiResult, implementation: impl } = await this.getAbiByAddress(abi, opts);
+            abiJson = abiResult;
+            implementation= impl;
+        } else {
+            let path = abi;
+            let location = opts?.location;
+            if (location && $path.isAbsolute(path) === false) {
+                // if path not relative, check the file at ClassFile location
+                let relPath = class_Uri.combine(location, path);
+                if (await File.existsAsync(relPath)) {
+                    path = relPath;
+                }
+            }
+            let json = await File.readAsync <any> (path);
+            abiJson = Array.isArray(json) ? json : json.abi;
+        }
+
+        $require.notNull(abiJson, `Abi not resolved from ${abi}`);
+        return { abiJson, implementation };
+    }
+
+
+    private async getAbiByAddress (abi: TAddress, opts: { implementation?: string }) {
+        let address = $address.expectValid(abi, 'contract address is not valid');
+        let platform = this.client.platform;
+        let explorer = $require.notNull(this.explorer, `Explorer not resolved for network: ${platform}`);
+
+        try {
+            $logger.log(`Loading contracts ABI for ${address}. `)
+            let { abi, implementation } = await explorer.getContractAbi(address, opts);
+
+            let hasProxy = $address.eq(address, implementation) === false;
+            $logger.log(`Proxy detected: ${hasProxy ? 'YES' : 'NO' }`, hasProxy ? implementation : '');
+
+            let abiJson = JSON.parse(abi) as AbiItem[];
+            return { abi: abiJson, implementation };
+        } catch (error) {
+            $logger.error(error);
+            throw new Error(`ABI is not resolved from ${platform}/${address}: ${error.message ?? error}`);
+        }
+    }
+}

package/src/contracts/ContractBase.ts

@@ -1,32 +1,42 @@
 import di from 'a-di';
 import memd from 'memd';
-import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import alot from 'alot';
 import type { Web3Client } from '@dequanto/clients/Web3Client';
-import { TAddress } from '@dequanto/models/TAddress';
-import { ContractReader } from './ContractReader';
-import { ContractWriter } from './ContractWriter';
-import { AbiItem } from 'web3-utils';
 import type { ITxWriterOptions, TxWriter } from '@dequanto/txs/TxWriter';
-import { $contract } from '@dequanto/utils/$contract';
+import type { Log, PastLogsOptions, Transaction, TransactionReceipt } from 'web3-core';
+import type { BufferLike } from 'ethereumjs-util';
+import type { TAccount } from "@dequanto/models/TAccount";
+import type { AbiItem } from 'web3-utils';
+import type { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import type { TAddress } from '@dequanto/models/TAddress';
+import type { ITxConfig } from '@dequanto/txs/ITxConfig';
+import type { BlockTransactionString } from 'web3-eth';
 import { utils } from 'ethers'
+import { $contract } from '@dequanto/utils/$contract';
+import { $class } from '@dequanto/utils/$class';
+import { $block } from '@dequanto/utils/$block';
+import { $abiParser } from '@dequanto/utils/$abiParser';
+import { ContractReader, ContractReaderUtils } from './ContractReader';
+import { ContractWriter } from './ContractWriter';
 import { ContractStream } from './ContractStream';
-import { TransactionReceipt } from 'web3-core';
-import { ITxConfig } from '@dequanto/txs/ITxConfig';
-import type { BufferLike } from 'ethereumjs-util';
 import { TxTopicInMemoryProvider } from '@dequanto/txs/receipt/TxTopicInMemoryProvider';
-import { $class } from '@dequanto/utils/$class';
+import { BlocksTxIndexer, TBlockListener } from '@dequanto/indexer/BlocksTxIndexer';
+import { SubjectStream } from '@dequanto/class/SubjectStream';
+import { $logger } from '@dequanto/utils/$logger';
+import { $address } from '@dequanto/utils/$address';
 
 
 export abstract class ContractBase {
     private blockNumber?: number;
     private blockDate?: Date;
+    //private from?: TAddress;
 
     /** 1.4 for medium*/
     private gasPriorityFee?: number
     private builderConfig?: ITxConfig;
     private writerConfig?: ITxWriterOptions;
 
-    abstract abi?: any
+    abstract abi?: AbiItem[]
 
     constructor (
         public address: TAddress,
@@ -41,17 +51,21 @@ export abstract class ContractBase {
         return reader.getStorageAt(this.address, position);
     }
     public parseInputData (buffer: string | BufferLike, value?: string) {
-        const inter = new utils.Interface(this.abi);
+        const inter = new utils.Interface(this.abi as any);
         const decodedInput = inter.parseTransaction({
             data: buffer as string,
             value: value,
         });
-        console.log("decodedInput", decodedInput);
         return {
             name: decodedInput.name,
             args: $contract.normalizeArgs(Array.from(decodedInput.args))
         };
     }
+    public async $executeBatch <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }> {
+
+        let reader = await this.getContractReader();
+        return reader.executeBatch(values);
+    }
 
     public $config (builderConfig?: ITxConfig, writerConfig?: ITxWriterOptions): this {
         let $contract = $class.curry(this, {
@@ -82,60 +96,175 @@ export abstract class ContractBase {
         return $contract;
     }
 
-    protected async $read (abi: string | AbiItem, ...params) {
-        let reader = await this.getContractReader();
+    protected $read (abi: string | AbiItem, ...params) {
+        if (this.builderConfig?.send === 'manual') {
+            let req = new ContractReaderUtils.DefferedRequest({
+                address: this.address,
+                abi,
+                params,
+                blockNumber: this.blockNumber ?? this.blockDate,
+                options: {
+                    from: this.builderConfig?.from
+                }
+            });
+            return req;
+        }
+        let reader = this.getContractReader();
         return reader.readAsync(this.address, abi, ...params);
     }
 
-    protected $on (event: string, cb) {
+    protected $onLog (event: string, cb?) {
         let stream = this.getContractStream();
-        return stream.on(event, cb);
+        let events = stream.on(event);
+        if (cb) {
+            events.onData(cb);
+        }
+        return events;
     }
 
+    protected $onTransaction (options?: BlockWalker.IBlockWalkerOptions): SubjectStream<{ tx: Transaction, block: BlockTransactionString, calldata: { method, arguments: any[] } }> {
 
-    protected async $write (abi: string | AbiItem, eoa: { address: TAddress, key: string, value?: number | string | bigint } , ...params): Promise<TxWriter> {
+        options ??= {};
 
+        type TSubject =  { tx: Transaction, block: BlockTransactionString, calldata: { method, arguments: any[] } };
+        let stream = new SubjectStream<TSubject>();
+
+        BlockWalker.onBlock(this.client, options, async (client, block, { txs }) => {
+            txs = txs.filter(x => $address.eq(x.to, this.address));
+            if (txs.length === 0) {
+                return;
+            }
+
+            txs.forEach(tx => {
+                try {
+                    let calldata = this.parseInputData(tx.input);
+                    let method = options.filter?.method;
+                    if (method != null && method !== '*') {
+                        if (calldata.name !== method) {
+                            return;
+                        }
+                    }
+                    let args = options.filter?.arguments;
+                    if (args != null) {
+                        for (let i = 0; i < args.length; i++) {
+                            let val = args[i];
+                            if (val != null && val != calldata.args[i]) {
+                                return;
+                            }
+                        }
+                    }
+                    stream.next({
+                        block,
+                        tx,
+                        calldata: { method: calldata.name, arguments: calldata.args }
+                    });
+                } catch (error) {
+                    $logger.log(`Unexpected exception onTx parser: ${error.message}`);
+                    stream.error(error);
+                }
+            })
+        });
+        return stream;
+    }
+
+    protected async $write (abi: string | AbiItem, account: TAccount & {  value?: number | string | bigint }, ...params): Promise<TxWriter> {
         let writer = await this.getContractWriter();
-        return writer.writeAsync(eoa, abi, params, {
+        return writer.writeAsync(account, abi, params, {
             builderConfig: this.builderConfig,
             writerConfig: this.writerConfig,
         });
     }
 
+    protected $getAbiItem (type: 'event' | 'function' | 'string', name: string, argsCount?: number) {
+        let arr = this.abi.filter(x => x.type === type && x.name === name);
+        if (arr.length === 0) {
+            throw new Error(`AbiItem ${name} not found`);
+        }
+        if (arr.length === 1) {
+            return arr[0];
+        }
+        if (argsCount == null) {
+            throw new Error(`Found multiple AbiItems for ${name}. Args count not specified to pick one`);
+        }
+        return arr.find(x => (x.inputs?.length ?? 0) === argsCount)
+    }
 
-    protected $getAbiItem (type: 'event' | 'function' | 'string', name: string) {
-        return this.abi.find(x => x.type === type && x.name === name);
+    protected $getAbiItemOverload (abis: string[], args: any[]) {
+        let $abis = abis
+            .map(methodAbi => $abiParser.parseMethod(methodAbi))
+            .filter(x => (x.inputs?.length ?? 0) === args.length);
+
+        if ($abis.length === 0) {
+            throw new Error(`ABI not found in overloads \n${abis.join('\n')}\n by arguments count. Got ${args.length} arguments`);
+        }
+        if ($abis.length === 1) {
+            return $abis[0];
+        }
+        throw new Error(`Not implemented exception. Got multiple overloads for the argument count ${args.length}. We should pick the ABI by parameters type.`)
     }
 
     protected $extractLogs (tx: TransactionReceipt, abiItem: AbiItem) {
         let logs = $contract.extractLogsForAbi(tx, abiItem);
-        return logs.map(log => {
-
-            let params = log.arguments.reduce((aggr, arg) => {
-                aggr[arg.name] = arg.value;
-                return aggr;
-            }, {});
-            return {
-                contract: log.contract,
-                arguments: log.arguments,
-                ...params
-            };
-        })
+        return logs;
+    }
+    protected $extractLog (log: Log, abiItem: AbiItem) {
+        let parsed = $contract.parseLogWithAbi(log, abiItem);
+        return parsed;
     }
+    protected async $getPastLogs(filters: PastLogsOptions) {
+        return this.client.getPastLogs(filters);
+    }
+    protected async $getPastLogsFilters(abi: AbiItem, options: {
+        topic: string
+        fromBlock?: number | Date
+        toBlock?: number | Date
+        params?: {
+            [key: string]: any
+        }
+    }): Promise<PastLogsOptions> {
+        let filters: PastLogsOptions = {};
+
+        if (options.fromBlock != null) {
+            filters.fromBlock = await $block.ensureNumber(options.fromBlock, this.client);
+        }
+        if (options.toBlock != null) {
+            filters.toBlock = await $block.ensureNumber(options.toBlock, this.client);
+        }
 
-    private async getContractReader () {
-        let reader = await this.getContractReaderInner();
+        let topics = [ options.topic ];
+        alot(abi.inputs)
+            .takeWhile(x => x.indexed)
+            .forEach(arg => {
+                let param = options.params?.[arg.name];
+                if (param == null) {
+                    topics.push(undefined);
+                    return;
+                }
+                topics.push(param);
+            })
+            .toArray();
+
+        filters.topics = topics;
+        return filters;
+    }
+
+    private getContractReader () {
+        let reader = this.getContractReaderInner();
         if (this.blockDate != null) {
             reader.forBlockAt(this.blockDate);
         }
         if (this.blockNumber != null) {
             reader.forBlock(this.blockNumber);
         }
+        let from = this.builderConfig?.from;
+        if (from != null) {
+            reader.withAddress(from);
+        }
         return reader;
     }
 
     @memd.deco.memoize({ perInstance: true })
-    private async getContractReaderInner () {
+    private getContractReaderInner () {
         let reader = di.resolve(ContractReader, this.client);
         return reader;
     }
@@ -156,3 +285,43 @@ export abstract class ContractBase {
         return stream;
     }
 }
+
+namespace BlockWalker {
+
+    export interface IBlockWalkerOptions {
+        name?: string,
+        persistance?: boolean,
+        //mempool?: boolean,
+        fromBlock?: number
+        filter?: {
+            method?: string,
+            arguments?: any[]
+        }
+    }
+
+    const indexers = {} as { [key: string]: BlocksTxIndexer } ;
+
+    export function onBlock (client: Web3Client, options: IBlockWalkerOptions, cb: TBlockListener ) {
+
+        let key = `${client.platform}_${options?.name ?? ''}_${options?.persistance ?? false}`;
+        let current = indexers[key];
+        if (current) {
+            current.onBlock(cb);
+            return current;
+        }
+
+        let indexer = new BlocksTxIndexer(client.platform, {
+            name: options.name,
+            persistance: options.persistance,
+            loadTransactions: true,
+            client: client,
+        });
+
+        indexers[key] = indexer;
+        indexer.onBlock(cb);
+        indexer.start();
+        return indexer;
+    }
+
+
+}