dequanto 0.0.1 → 0.0.7

package/dist/src/contracts/ContractBase.js

@@ -12,13 +12,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractBase = void 0;
 const a_di_1 = __importDefault(require("a-di"));
 const memd_1 = __importDefault(require("memd"));
+const alot_1 = __importDefault(require("alot"));
+const ethers_1 = require("ethers");
+const _contract_1 = require("@dequanto/utils/$contract");
+const _class_1 = require("@dequanto/utils/$class");
+const _block_1 = require("@dequanto/utils/$block");
+const _abiParser_1 = require("@dequanto/utils/$abiParser");
 const ContractReader_1 = require("./ContractReader");
 const ContractWriter_1 = require("./ContractWriter");
-const _contract_1 = require("@dequanto/utils/$contract");
-const ethers_1 = require("ethers");
 const ContractStream_1 = require("./ContractStream");
 const TxTopicInMemoryProvider_1 = require("@dequanto/txs/receipt/TxTopicInMemoryProvider");
-const _class_1 = require("@dequanto/utils/$class");
+const BlocksTxIndexer_1 = require("@dequanto/indexer/BlocksTxIndexer");
+const SubjectStream_1 = require("@dequanto/class/SubjectStream");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _address_1 = require("@dequanto/utils/$address");
 class ContractBase {
     constructor(address, client, explorer) {
         this.address = address;
@@ -35,12 +42,15 @@ class ContractBase {
             data: buffer,
             value: value,
         });
-        console.log("decodedInput", decodedInput);
         return {
             name: decodedInput.name,
             args: _contract_1.$contract.normalizeArgs(Array.from(decodedInput.args))
         };
     }
+    async $executeBatch(values) {
+        let reader = await this.getContractReader();
+        return reader.executeBatch(values);
+    }
     $config(builderConfig, writerConfig) {
         let $contract = _class_1.$class.curry(this, {
             builderConfig: builderConfig,
@@ -68,49 +78,151 @@ class ContractBase {
         });
         return $contract;
     }
-    async $read(abi, ...params) {
-        let reader = await this.getContractReader();
+    $read(abi, ...params) {
+        if (this.builderConfig?.send === 'manual') {
+            let req = new ContractReader_1.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);
     }
-    $on(event, cb) {
+    $onLog(event, cb) {
         let stream = this.getContractStream();
-        return stream.on(event, cb);
+        let events = stream.on(event);
+        if (cb) {
+            events.onData(cb);
+        }
+        return events;
     }
-    async $write(abi, eoa, ...params) {
+    $onTransaction(options) {
+        options ?? (options = {});
+        let stream = new SubjectStream_1.SubjectStream();
+        BlockWalker.onBlock(this.client, options, async (client, block, { txs }) => {
+            txs = txs.filter(x => _address_1.$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_1.$logger.log(`Unexpected exception onTx parser: ${error.message}`);
+                    stream.error(error);
+                }
+            });
+        });
+        return stream;
+    }
+    async $write(abi, account, ...params) {
         let writer = await this.getContractWriter();
-        return writer.writeAsync(eoa, abi, params, {
+        return writer.writeAsync(account, abi, params, {
             builderConfig: this.builderConfig,
             writerConfig: this.writerConfig,
         });
     }
-    $getAbiItem(type, name) {
-        return this.abi.find(x => x.type === type && x.name === name);
+    $getAbiItem(type, name, argsCount) {
+        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);
+    }
+    $getAbiItemOverload(abis, args) {
+        let $abis = abis
+            .map(methodAbi => _abiParser_1.$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.`);
     }
     $extractLogs(tx, abiItem) {
         let logs = _contract_1.$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;
+    }
+    $extractLog(log, abiItem) {
+        let parsed = _contract_1.$contract.parseLogWithAbi(log, abiItem);
+        return parsed;
+    }
+    async $getPastLogs(filters) {
+        return this.client.getPastLogs(filters);
     }
-    async getContractReader() {
-        let reader = await this.getContractReaderInner();
+    async $getPastLogsFilters(abi, options) {
+        let filters = {};
+        if (options.fromBlock != null) {
+            filters.fromBlock = await _block_1.$block.ensureNumber(options.fromBlock, this.client);
+        }
+        if (options.toBlock != null) {
+            filters.toBlock = await _block_1.$block.ensureNumber(options.toBlock, this.client);
+        }
+        let topics = [options.topic];
+        (0, alot_1.default)(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;
+    }
+    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;
     }
-    async getContractReaderInner() {
+    getContractReaderInner() {
         let reader = a_di_1.default.resolve(ContractReader_1.ContractReader, this.client);
         return reader;
     }
@@ -137,3 +249,26 @@ __decorate([
     memd_1.default.deco.memoize({ perInstance: true })
 ], ContractBase.prototype, "getContractStream", null);
 exports.ContractBase = ContractBase;
+var BlockWalker;
+(function (BlockWalker) {
+    const indexers = {};
+    function onBlock(client, options, cb) {
+        let key = `${client.platform}_${options?.name ?? ''}_${options?.persistance ?? false}`;
+        let current = indexers[key];
+        if (current) {
+            current.onBlock(cb);
+            return current;
+        }
+        let indexer = new BlocksTxIndexer_1.BlocksTxIndexer(client.platform, {
+            name: options.name,
+            persistance: options.persistance,
+            loadTransactions: true,
+            client: client,
+        });
+        indexers[key] = indexer;
+        indexer.onBlock(cb);
+        indexer.start();
+        return indexer;
+    }
+    BlockWalker.onBlock = onBlock;
+})(BlockWalker || (BlockWalker = {}));

package/dist/src/contracts/ContractReader.js

@@ -3,15 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContractReader = void 0;
+exports.ContractReaderUtils = exports.ContractReader = void 0;
 const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
 const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
-const _abiParser_1 = require("../utils/$abiParser");
 const AbiDeserializer_1 = require("./utils/AbiDeserializer");
 const BlockDateResolver_1 = require("@dequanto/blocks/BlockDateResolver");
+const atma_utils_1 = require("atma-utils");
+const _is_1 = require("@dequanto/utils/$is");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _abiParser_1 = require("../utils/$abiParser");
 class ContractReader {
     constructor(client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
         this.client = client;
+        this.options = {};
     }
     forBlock(blockNumber) {
         this.blockNumberTask = blockNumber == null
@@ -29,6 +34,10 @@ class ContractReader {
         }
         return this;
     }
+    withAddress(address) {
+        this.options.from = address;
+        return this;
+    }
     async getStorageAt(address, position) {
         let blockNumber = void 0;
         if (this.blockNumberTask != null) {
@@ -57,6 +66,7 @@ class ContractReader {
                 method: method,
                 arguments: params,
                 blockNumber: blockNumber,
+                options: this.options
             });
             if (result == null) {
                 throw new Error(`Function call returned undefined`);
@@ -68,9 +78,75 @@ class ContractReader {
             throw new Error(`Contract: ${address} ${methodAbi} with \n${args}\nfailed with ${error.message}`);
         }
     }
+    async executeBatch(values) {
+        let requests = await (0, alot_1.default)(values)
+            .mapAsync(async (x) => await x)
+            .toArrayAsync();
+        // all inputs should be deferred requests
+        let invalid = requests.find(x => _is_1.$is.Address(x.request?.address) === false);
+        if (invalid != null) {
+            _logger_1.$logger.error('Invalid object', invalid);
+            throw new Error(`Invalid Deferred Request at position ${requests.indexOf(invalid)}`);
+        }
+        let inputs = await (0, alot_1.default)(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,
+            };
+        }).toArrayAsync();
+        let results = await ContractReaderUtils.readAsyncBatch(this.client, inputs);
+        return results;
+    }
+    async getLogs() {
+    }
     static async read(client, address, methodAbi) {
         let reader = new ContractReader(client);
         return reader.readAsync(address, methodAbi);
     }
 }
 exports.ContractReader = ContractReader;
+var ContractReaderUtils;
+(function (ContractReaderUtils) {
+    class DefferedRequest {
+        constructor(request) {
+            this.request = request;
+            this.promise = Object.assign(new atma_utils_1.class_Dfr(), {
+                request: this
+            });
+        }
+    }
+    ContractReaderUtils.DefferedRequest = DefferedRequest;
+    async function readAsyncBatch(client, requests) {
+        let reqs = await (0, alot_1.default)(requests).map(async (request) => {
+            let abi = request.abi;
+            if (typeof abi === 'string') {
+                abi = _abiParser_1.$abiParser.parseMethod(abi);
+            }
+            let blockNumber = request.blockNumber;
+            if (blockNumber instanceof Date) {
+                let resolver = a_di_1.default.resolve(BlockDateResolver_1.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_1.AbiDeserializer.process(result, outputs);
+        });
+    }
+    ContractReaderUtils.readAsyncBatch = readAsyncBatch;
+})(ContractReaderUtils = exports.ContractReaderUtils || (exports.ContractReaderUtils = {}));

package/dist/src/contracts/ContractStorageReaderBase.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractStorageReaderBase = void 0;
+const SlotsStorage_1 = require("@dequanto/solidity/SlotsStorage");
+class ContractStorageReaderBase {
+    constructor(address, client, explorer) {
+        this.address = address;
+        this.client = client;
+        this.explorer = explorer;
+    }
+    $createHandler(slots) {
+        this.$storage = SlotsStorage_1.SlotsStorage.createWithClient(this.client, this.address, slots);
+    }
+}
+exports.ContractStorageReaderBase = ContractStorageReaderBase;

package/dist/src/contracts/ContractStream.js

@@ -1,20 +1,33 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractStream = void 0;
-const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
-const a_di_1 = __importDefault(require("a-di"));
+const ClientEventsStream_1 = require("@dequanto/clients/ClientEventsStream");
+const _require_1 = require("@dequanto/utils/$require");
 class ContractStream {
-    constructor(address, abi, client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+    constructor(address, abi, client) {
         this.address = address;
         this.abi = abi;
         this.client = client;
+        _require_1.$require.Address(address);
     }
-    on(event, cb) {
+    on(event) {
+        if (event === '*') {
+            let stream = new ClientEventsStream_1.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;
     }
 }
 exports.ContractStream = ContractStream;

package/dist/src/contracts/ContractWriter.js

@@ -11,6 +11,8 @@ const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
 const _abiParser_1 = require("../utils/$abiParser");
 const _logger_1 = require("@dequanto/utils/$logger");
 const _class_1 = require("@dequanto/utils/$class");
+const _account_1 = require("@dequanto/utils/$account");
+const _require_1 = require("@dequanto/utils/$require");
 class ContractWriter {
     constructor(address, client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
         this.address = address;
@@ -22,8 +24,32 @@ class ContractWriter {
             writerConfig: writerConfig ?? this.writerConfig,
         });
     }
-    async writeAsync(eoa, interfaceAbi, params, configs) {
-        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, eoa, {
+    /**
+    * 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(account, interfaceAbi, params, configs) {
+        _require_1.$require.notNull(account, 'Account parameter is undefined.');
+        let value = typeof account !== 'string'
+            ? account.value
+            : null;
+        let isSafe = _account_1.$account.isSafe(account);
+        let sender = _account_1.$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_1.TxDataBuilder(this.client, sender, {
             to: this.address
         });
         let abi = typeof interfaceAbi === 'string'
@@ -34,25 +60,26 @@ class ContractWriter {
             ...(configs?.builderConfig ?? {}),
         };
         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);
-        let writer = TxWriter_1.TxWriter.write(this.client, txBuilder, eoa, configs?.writerConfig ?? this.writerConfig);
+        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_1.TxWriter.write(this.client, txBuilder, account, configs?.writerConfig ?? this.writerConfig);
         writer.on('log', message => {
             _logger_1.$logger.log(`TxContract ${abi.name}; ${message}`);
         });

package/dist/src/contracts/TxContract.js

@@ -10,12 +10,15 @@ const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
 const ethers_1 = require("ethers");
 const ContractProvider_1 = require("./ContractProvider");
 class TxContract {
-    constructor(loader = a_di_1.default.resolve(Etherscan_1.Etherscan)) {
-        this.loader = loader;
-        this.provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, this.loader);
+    constructor(explorer = a_di_1.default.resolve(Etherscan_1.Etherscan)) {
+        this.explorer = explorer;
+        this.provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, this.explorer);
     }
     async parseTrasaction(tx) {
         const abi = await this.provider.getAbi(tx.to);
+        return this.parseTrasactionWithAbi(tx, abi);
+    }
+    async parseTrasactionWithAbi(tx, abi) {
         const inter = new ethers_1.utils.Interface(abi);
         const decodedInput = inter.parseTransaction({
             data: tx.input,

package/dist/src/contracts/common/ERC20.js

@@ -8,7 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERC20 = void 0;
-const ERC20Base_1 = require("@dequanto-contracts/gen/base/ERC20Base");
+const ERC20Base_1 = require("@dequanto-contracts/gen/base/ERC20Base/ERC20Base");
 class ERC20 extends ERC20Base_1.ERC20Base {
 }
 exports.ERC20 = ERC20;

package/dist/src/contracts/utils/AbiDeserializer.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbiDeserializer = void 0;
+const _str_1 = require("@dequanto/solidity/utils/$str");
 const _abiType_1 = require("@dequanto/utils/$abiType");
+const _is_1 = require("@dequanto/utils/$is");
 const _abiParser_1 = require("../../utils/$abiParser");
 var AbiDeserializer;
 (function (AbiDeserializer) {
     function process(result, types) {
         let type = _abiParser_1.$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]);
     }
@@ -27,6 +31,12 @@ var AbiDeserializer;
                     return BigInt(val);
                 case 'number':
                     return Number(val);
+                case 'boolean':
+                    return Boolean(Number(val));
+                case 'string':
+                    return _is_1.$is.hexString(val)
+                        ? _str_1.$str.fromHex(val)
+                        : val;
             }
         }
         if (type.type === 'tuple[]') {

package/dist/src/contracts/utils/InputDataUtils.js

@@ -7,6 +7,9 @@ var InputDataUtils;
 (function (InputDataUtils) {
     function split(inputData) {
         let str = inputData.substring(2);
+        if (str === '') {
+            return { method: '', args: [] };
+        }
         let methodName = str.substring(0, 8);
         let params = str.substring(8);
         let args = [];
@@ -39,7 +42,7 @@ var InputDataUtils;
     }
     InputDataUtils.decodeParamsWithABI = decodeParamsWithABI;
     function decodeWithABI(IFunctionABI, ...params) {
-        let iface = new ethers_1.ethers.utils.Interface([IFunctionABI]);
+        let iface = new ethers_1.utils.Interface([IFunctionABI]);
         let methodName;
         if (typeof IFunctionABI === 'string') {
             methodName = /function \s*(?<methodName>[\w\d_]+)/.exec(IFunctionABI)?.groups?.methodName;
@@ -57,7 +60,7 @@ var InputDataUtils;
      * function work(uint256 id, address worker, uint256 principalAmount, uint256 loan, uint256 maxReturn, bytes calldata data)
      */
     function encodeWithABI(IFunctionABI, ...params) {
-        let iface = new ethers_1.ethers.utils.Interface([IFunctionABI]);
+        let iface = new ethers_1.utils.Interface([IFunctionABI]);
         let methodName;
         if (typeof IFunctionABI === 'string') {
             methodName = /function \s*(?<methodName>[\w\d_]+)/.exec(IFunctionABI)?.groups?.methodName;

package/dist/src/env/BigIntSerializer.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BigIntSerializer = void 0;
+const _buffer_1 = require("@dequanto/utils/$buffer");
 BigInt.prototype.toJSON = function () { return this.toString(); };
 BigInt.prototype.toBuffer = function () {
     let hex = this.toString(16);
     if (hex.length % 2 !== 0) {
         hex = `0${hex}`;
     }
-    return Buffer.from(hex, 'hex');
+    return _buffer_1.$buffer.fromHex(hex);
 };
 BigInt.prototype.valueOf = function () {
     if (this > BigInt(Number.MAX_VALUE)) {