dequanto 0.0.1 → 0.0.7

package/src/contracts/ContractReader.ts

@@ -1,11 +1,15 @@
 import di from 'a-di';
+import alot from 'alot';
+import { type AbiItem } from 'web3-utils';
+import { type Web3Client } from '@dequanto/clients/Web3Client';
 import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
-import { AbiItem } from 'web3-utils';
-import { Web3Client } from '@dequanto/clients/Web3Client';
-import { $abiParser } from '../utils/$abiParser';
 import { AbiDeserializer } from './utils/AbiDeserializer';
 import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
 import { TAddress } from '@dequanto/models/TAddress';
+import { class_Dfr } from 'atma-utils';
+import { $is } from '@dequanto/utils/$is';
+import { $logger } from '@dequanto/utils/$logger';
+import { $abiParser } from '../utils/$abiParser';
 
 
 export interface IContractReader {
@@ -16,6 +20,7 @@ export interface IContractReader {
 }
 export class ContractReader implements IContractReader {
     private blockNumberTask: Promise<number>;
+    private options: Parameters<Web3Client['readContract']>[0]['options'] = {};
 
     constructor(public client: Web3Client = di.resolve(EthWeb3Client)) {
 
@@ -35,6 +40,10 @@ export class ContractReader implements IContractReader {
         }
         return this;
     }
+    withAddress (address: TAddress): IContractReader {
+        this.options.from = address;
+        return this;
+    }
 
     async getStorageAt(address: TAddress, position: string | number | bigint) {
         let blockNumber: number = void 0;
@@ -67,6 +76,7 @@ export class ContractReader implements IContractReader {
                 method: method,
                 arguments: params,
                 blockNumber: blockNumber,
+                options: this.options
             });
             if (result == null) {
                 throw new Error(`Function call returned undefined`);
@@ -80,8 +90,111 @@ export class ContractReader implements IContractReader {
         }
     }
 
+    public async executeBatch <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }> {
+
+        let requests = await alot(values as any[])
+            .mapAsync(async x => await x)
+            .toArrayAsync() as ContractReaderUtils.DefferedRequest[];
+
+        // all inputs should be deferred requests
+        let invalid = requests.find(x => $is.Address(x.request?.address) === false);
+        if (invalid != null) {
+            $logger.error('Invalid object', invalid);
+            throw new Error(`Invalid Deferred Request at position ${ requests.indexOf(invalid) }`);
+        }
+
+        let inputs = await alot(requests).mapAsync(async req => {
+            return {
+                address: req.request.address,
+                abi: req.request.abi,
+                params: req.request.params,
+                blockNumber: req.request.blockNumber,
+                options: req.request.options,
+            } as ContractReaderUtils.IContractReadParams;
+        }).toArrayAsync();
+
+        let results = await ContractReaderUtils.readAsyncBatch(this.client, inputs);
+        return results as any;
+    }
+
+    async getLogs () {
+
+    }
+
     static async read (client: Web3Client, address: TAddress, methodAbi: string){
         let reader = new ContractReader(client);
         return reader.readAsync(address, methodAbi);
     }
 }
+
+export namespace ContractReaderUtils {
+
+
+    export class DefferedRequest<T = any> {
+
+        public promise: class_Dfr<T> & {
+            request: DefferedRequest
+        }
+
+        constructor (
+            public request: {
+                address: TAddress,
+                abi: string | AbiItem,
+                params: any[],
+                blockNumber?: Date | number,
+                options?: {
+                    from?: TAddress
+                },
+            }
+        ) {
+
+            this.promise = Object.assign(new class_Dfr(), {
+                request: this
+            });
+        }
+    }
+
+
+    export interface IContractReadParams {
+        address: TAddress,
+        abi: string | AbiItem
+        params?: any[]
+
+        blockNumber?: number | Date
+        options?: {
+            from?: TAddress
+        }
+    }
+
+    export async function readAsyncBatch(client: Web3Client, requests: IContractReadParams[]) {
+
+        let reqs = await alot(requests).map(async request => {
+            let abi = request.abi;
+            if (typeof abi === 'string') {
+                abi = $abiParser.parseMethod(abi);
+            }
+            let blockNumber = request.blockNumber;
+            if (blockNumber instanceof Date) {
+                let resolver = di.resolve(BlockDateResolver, client);
+                blockNumber = await resolver.getBlockNumberFor(blockNumber);
+            }
+            return {
+                address: request.address,
+                abi: [ abi ],
+                method: abi.name,
+                arguments: request.params,
+                blockNumber: blockNumber,
+                options: request.options
+            };
+        }).toArrayAsync();
+
+        let results = await client.readContractBatch(reqs);
+        return results.map((result, i) => {
+            if (result == null || result instanceof Error) {
+                return result;
+            }
+            let outputs = reqs[i].abi[0].outputs;
+            return AbiDeserializer.process(result, outputs);
+        });
+    }
+}

package/src/contracts/ContractStorageReaderBase.ts

@@ -0,0 +1,26 @@
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { ISlotVarDefinition } from '@dequanto/solidity/SlotsParser';
+import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
+
+export class ContractStorageReaderBase {
+
+
+
+    public $storage: SlotsStorage;
+
+
+    constructor (
+        public address: TAddress,
+        public client: Web3Client,
+        public explorer: IBlockChainExplorer
+    ) {
+
+    }
+
+
+    protected $createHandler(slots: ISlotVarDefinition[]) {
+        this.$storage = SlotsStorage.createWithClient(this.client, this.address, slots);
+    }
+}

package/src/contracts/ContractStream.ts

@@ -1,18 +1,36 @@
+import di from 'a-di';
 import { ClientEventsStream } from '@dequanto/clients/ClientEventsStream';
-import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { TAddress } from '@dequanto/models/TAddress';
-import di from 'a-di';
+import { type AbiItem } from 'web3-utils';
+import { $require } from '@dequanto/utils/$require';
 
 export class ContractStream  {
 
-    constructor(public address: TAddress, public abi: any, public client: Web3Client = di.resolve(EthWeb3Client)) {
-
+    constructor(public address: TAddress, public abi: AbiItem[], public client: Web3Client) {
+        $require.Address(address);
     }
 
-    on(event: string, cb): ClientEventsStream<any> {
+    on(event: '*' | string): ClientEventsStream<any> {
+        if (event === '*') {
+            let stream = new ClientEventsStream(this.address, this.abi)
+            this
+                .client
+                .subscribe('logs', {
+                    address: this.address,
+                    fromBlock: 'latest'
+                })
+                .then(subscription => {
+                    stream.fromSubscription(subscription);
+                }, error => {
+                    stream.error(error);
+                });
+
+            return stream;
+        }
+
         let stream = this.client.getEventStream(this.address, this.abi, event);
-        return stream.onData(cb);
+        return stream;
     }
 }
 

package/src/contracts/ContractWriter.ts

@@ -1,24 +1,25 @@
 import di from 'a-di';
+import type { AbiItem } from 'web3-utils';
 import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
-import { AbiItem } from 'web3-utils';
 import { ITxWriterOptions, TxWriter } from '@dequanto/txs/TxWriter';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
 import { TAddress } from '@dequanto/models/TAddress';
-import { $abiType } from '@dequanto/utils/$abiType';
 import { $abiParser } from '../utils/$abiParser';
-import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccount, TAccount } from "@dequanto/models/TAccount";
 import { ITxConfig } from '@dequanto/txs/ITxConfig';
-import { $bigint } from '@dequanto/utils/$bigint';
 import { $logger } from '@dequanto/utils/$logger';
 import { $class } from '@dequanto/utils/$class';
+import { $account } from '@dequanto/utils/$account';
+import { $require } from '@dequanto/utils/$require';
 
 interface IChainAccountSender extends ChainAccount {
     value?: number | string | bigint
 }
 
+
 export interface IContractWriter {
-    writeAsync <T = any> (eoa: { address?: string, key: string }, methodAbi: string | AbiItem, ...params: any[]): Promise<TxWriter>
+    writeAsync<T = any>(eoa: { address?: string, key: string }, methodAbi: string | AbiItem, ...params: any[]): Promise<TxWriter>
 }
 
 export class ContractWriter implements IContractWriter {
@@ -31,15 +32,25 @@ export class ContractWriter implements IContractWriter {
 
     }
 
-    $config (builderConfig?: ITxConfig, writerConfig?: ITxWriterOptions): this {
+    $config(builderConfig?: ITxConfig, writerConfig?: ITxWriterOptions): this {
         return $class.curry(this, {
             builderConfig: builderConfig ?? this.builderConfig,
             writerConfig: writerConfig ?? this.writerConfig,
         });
     }
 
+    /**
+    * We split Tx sending in two awaitable steps
+    * 1. This method prepairs(gas, nonce, etc) - and sends the Tx
+    * 2. With returned writer you can subscribe to events and/or wait for Tx to be mined
+    * @param account
+    * @param interfaceAbi
+    * @param params
+    * @param configs
+    * @returns {TxWriter}
+     */
     async writeAsync<T = any>(
-        eoa: IChainAccountSender,
+        account: TAccount & {  value?: number | string | bigint },
         interfaceAbi: string | AbiItem,
         params: any[],
         configs?: {
@@ -48,7 +59,24 @@ export class ContractWriter implements IContractWriter {
         }
     ): Promise<TxWriter> {
 
-        let txBuilder = new TxDataBuilder(this.client, eoa, {
+        $require.notNull(account, 'Account parameter is undefined.');
+
+        let value = typeof account !== 'string'
+            ? account.value
+            : null;
+
+        let isSafe = $account.isSafe(account);
+        let sender = $account.getSender(account);
+        // if (sender.key == null) {
+        //     let addressOrName = sender.address ?? sender.name;
+        //     let service = di.resolve(ChainAccountsService);
+        //     let fromStorage = await service.get(addressOrName, this.client.platform);
+        //     if (fromStorage) {
+        //         account = fromStorage;
+        //     }
+        // }
+
+        let txBuilder = new TxDataBuilder(this.client, sender, {
             to: this.address
         });
 
@@ -62,34 +90,36 @@ export class ContractWriter implements IContractWriter {
         };
 
         txBuilder.setConfig(builderConfig);
-        txBuilder.setValue(eoa.value);
+        txBuilder.setValue(value);
         txBuilder.setInputDataWithABI(abi, ...params);
-        await Promise.all([
-            txBuilder.setGas({
-                price: builderConfig.gasPrice,
-                priceRatio: builderConfig.gasPriceRatio,
-                gasLimit: builderConfig.gasLimit,
-                gasLimitRatio: builderConfig.gasLimitRatio,
-                gasEstimation: builderConfig.gasEstimation,
-                from: builderConfig.from ?? eoa.address,
-                type: builderConfig.type ?? null,
-            }),
-            txBuilder.setNonce({
-                nonce: builderConfig.nonce,
-                noncePending: builderConfig.noncePending,
-            }),
-        ]);
-
-        console.log(txBuilder.data, eoa, this.address);
+
+        if (isSafe !== true) {
+            await Promise.all([
+                txBuilder.setGas({
+                    price: builderConfig.gasPrice,
+                    priceRatio: builderConfig.gasPriceRatio,
+                    gasLimit: builderConfig.gasLimit,
+                    gasLimitRatio: builderConfig.gasLimitRatio,
+                    gasEstimation: builderConfig.gasEstimation,
+                    from: builderConfig.from ?? sender.address,
+                    type: builderConfig.type ?? null,
+                }),
+                txBuilder.setNonce({
+                    nonce: builderConfig.nonce,
+                    noncePending: builderConfig.noncePending,
+                }),
+            ]);
+        }
+
         let writer = TxWriter.write(
             this.client,
             txBuilder,
-            eoa,
+            account,
             configs?.writerConfig ?? this.writerConfig
         );
 
         writer.on('log', message => {
-            $logger.log(`TxContract ${ abi.name}; ${message}`);
+            $logger.log(`TxContract ${abi.name}; ${message}`);
         });
         return writer;
     }

package/src/contracts/TxContract.ts

@@ -7,25 +7,28 @@ import { utils } from 'ethers'
 import { TransactionDescription } from 'ethers/lib/utils';
 import { Transaction } from 'web3-core';
 import { ContractProvider } from './ContractProvider';
-
+import type { AbiItem } from 'web3-utils';
 
 export class TxContract {
 
-    private provider = di.resolve(ContractProvider, this.loader);
+    private provider = di.resolve(ContractProvider, this.explorer);
 
-    constructor (private loader: IBlockChainExplorer = di.resolve(Etherscan)) {
+    constructor (private explorer: IBlockChainExplorer = di.resolve(Etherscan)) {
 
     }
 
     async parseTrasaction (tx: Transaction): Promise<TransactionDescription> {
         const abi = await this.provider.getAbi(tx.to);
 
+        return this.parseTrasactionWithAbi(tx, abi);
+    }
+
+    async parseTrasactionWithAbi (tx: Transaction, abi): Promise<TransactionDescription> {
         const inter = new utils.Interface(abi);
         const decodedInput = inter.parseTransaction({
             data: tx.input,
             value: tx.value,
         });
-
         return decodedInput;
     }
 

package/src/contracts/common/ERC20.ts

@@ -6,7 +6,7 @@
  * output: ./contracts/gen/base/
  */
 
-import { ERC20Base } from '@dequanto-contracts/gen/base/ERC20Base';
+import { ERC20Base } from '@dequanto-contracts/gen/base/ERC20Base/ERC20Base';
 
 export class ERC20 extends ERC20Base {
 

package/src/contracts/utils/AbiDeserializer.ts

@@ -1,5 +1,7 @@
+import { $str } from '@dequanto/solidity/utils/$str';
 import { $abiType } from '@dequanto/utils/$abiType';
-import { AbiItem, AbiOutput } from 'web3-utils';
+import { $is } from '@dequanto/utils/$is';
+import { type AbiItem, AbiOutput } from 'web3-utils';
 import { $abiParser } from '../../utils/$abiParser';
 
 export namespace AbiDeserializer {
@@ -8,11 +10,13 @@ export namespace AbiDeserializer {
 
     export function process(result: any, types: AbiOutput[]) {
         let type: 'array' | 'object' | AbiNativeType = $abiParser.getReturnTypeFromTypes(types);
-        if (type === 'array') {
-            return toArray(result, types)
-        }
-        if (type === 'object') {
-            return toObject(result, types);
+        if (typeof result === 'object') {
+            if (type === 'array') {
+                return toArray(result, types)
+            }
+            if (type === 'object') {
+                return toObject(result, types);
+            }
         }
         return toType(result, types[0]);
     }
@@ -25,12 +29,17 @@ export namespace AbiDeserializer {
         }
         if (typeof val === 'string') {
             let tsType = $abiType.getTsType(type.type);
-
             switch (tsType) {
                 case 'bigint':
                     return BigInt(val);
                 case 'number':
                     return Number(val);
+                case 'boolean':
+                    return Boolean(Number(val));
+                case 'string':
+                    return $is.hexString(val)
+                        ? $str.fromHex(val)
+                        : val;
             }
         }
         if (type.type === 'tuple[]') {

package/src/contracts/utils/InputDataUtils.ts

@@ -1,12 +1,14 @@
-import { IWeb3Client } from '@dequanto/clients/interfaces/IWeb3Client';
 import { Web3Client } from '@dequanto/clients/Web3Client';
-import { ethers, utils } from 'ethers';
-import { AbiItem } from 'web3-utils';
+import { utils } from 'ethers';
+import { type AbiItem } from 'web3-utils';
 import { $abiParser } from '../../utils/$abiParser';
 
 export namespace InputDataUtils {
-    export function split (inputData: string) {
+    export function split (inputData: string): { method: string, args: string[] } {
         let str = inputData.substring(2);
+        if (str === '') {
+            return { method: '', args: [] }
+        }
         let methodName = str.substring(0, 8);
         let params = str.substring(8);
         let args = [];
@@ -43,7 +45,7 @@ export namespace InputDataUtils {
         return normalizeArgs(arr);
     }
     export function decodeWithABI (IFunctionABI: string | AbiItem, ...params): string {
-        let iface = new ethers.utils.Interface([ IFunctionABI as any ]);
+        let iface = new utils.Interface([ IFunctionABI as any ]);
         let methodName: string;
 
         if (typeof IFunctionABI === 'string') {
@@ -63,7 +65,7 @@ export namespace InputDataUtils {
      * function work(uint256 id, address worker, uint256 principalAmount, uint256 loan, uint256 maxReturn, bytes calldata data)
      */
     export function encodeWithABI (IFunctionABI: string | AbiItem, ...params): string {
-        let iface = new ethers.utils.Interface([ IFunctionABI as any ]);
+        let iface = new utils.Interface([ IFunctionABI as any ]);
         let methodName: string;
 
         if (typeof IFunctionABI === 'string') {

package/src/env/BigIntSerializer.ts

@@ -1,10 +1,12 @@
+import { $buffer } from '@dequanto/utils/$buffer';
+
 (BigInt as any).prototype.toJSON = function () { return this.toString() };
 (BigInt as any).prototype.toBuffer = function () {
     let hex = (this as bigint).toString(16);
     if (hex.length % 2 !== 0) {
         hex = `0${hex}`;
     }
-    return Buffer.from(hex, 'hex');
+    return $buffer.fromHex(hex);
 };
 
 (BigInt as any).prototype.valueOf = function () {