dequanto 0.0.1

package/src/txs/conditional/GasWatcherTx.ts

@@ -0,0 +1,143 @@
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $logger } from '@dequanto/utils/$logger';
+import { id } from 'ethers/lib/utils';
+import { TTxWriterJson, TxWriter } from '../TxWriter';
+import { GasWatcherLogger } from './GasWatcherLogger';
+
+export interface IGasWatcherCondition {
+    price: bigint
+}
+
+export class GasWatcherTx {
+
+    static async fromJSON (conditionJson: IGasWatcherCondition, writerJson: TTxWriterJson, logger: GasWatcherLogger) {
+        let writer = await TxWriter.fromJSON(writerJson);
+        return new GasWatcherTx({
+            price: BigInt(conditionJson.price)
+        }, writer, logger);
+    }
+
+    protected constructor (
+        public condition: IGasWatcherCondition,
+        public txWriter: TxWriter,
+        public logger: GasWatcherLogger,
+    ) {
+        txWriter.on('log', message => this.log(message));
+    }
+
+    toJSON () {
+        return {
+            condition: this.condition,
+            writer: this.txWriter.toJSON(),
+        };
+    }
+
+    async tick (gasPrice: bigint) {
+        if (gasPrice > this.condition.price) {
+            // condition not matched
+            return;
+        }
+        if (this.txWriter.receipt != null) {
+            this.log(`Tx was already mined: ${this.txWriter.receipt.transactionHash}`);
+            return;
+        }
+
+        let tx = this.txWriter.tx;
+        if (tx == null) {
+            this.send(gasPrice);
+            return;
+        }
+
+        let timeEllipsedS = (Date.now() - tx.timestamp) / 1000 | 0;
+        if (tx.hash == null) {
+            if (timeEllipsedS > 30) {
+                // tx was not accepted for 30s
+                this.log(`Tx was not accepted for 30s. Resend`);
+                this.send(gasPrice);
+            }
+            // otherwise let wait for a hash
+            return;
+        }
+        let hash = tx.hash;
+        let client = this.txWriter.client;
+        let txData = await client.getTransaction(hash);
+
+        if (this.txWriter.receipt) {
+            // was mined inbetween
+            return;
+        }
+        if (txData == null) {
+            if (timeEllipsedS > 45) {
+                this.log(`Tx not in a pending block: ${hash}. Resend`);
+                // tx not in a pending block
+                this.send(gasPrice);
+            }
+            // otherwise let wait to be included into the pending block
+            return;
+        }
+
+        if (timeEllipsedS > 60 * 5) {
+            this.log(`Tx 5mins not mined: ${hash}. Resend`);
+            // 5mins not mined;
+            this.send(gasPrice);
+        }
+    }
+
+    private async send (gasPrice: bigint) {
+        let writer = this.txWriter;
+        let builder = writer.builder;
+        let data = builder.data;
+        if (data.nonce == null) {
+            throw new Error(`Nonce should be already set on initial tx creating`);
+            await builder.setNonce();
+        }
+        if (writer.tx && data.gasPrice) {
+            // re-submitting
+            let currentGas = BigInt(data.gasPrice.toString());
+            if (currentGas >= gasPrice) {
+                // we can't resubmit with less gas
+                gasPrice = currentGas + $bigint.toWeiFromGwei(.1);
+            }
+        }
+
+        await builder.setGas({
+            price: gasPrice,
+            priceRatio: 1,
+            gasLimit: data.gasLimit as number,
+        });
+
+        writer.tx = null;
+        writer.on('transactionHash', hash => {
+            let pendingCount = 0;
+            let nullCount = 0;
+            let interval = setInterval(async () => {
+                let tx = await writer.client.getTransaction(hash);
+                $logger.log('Check', hash, 'Block', tx?.blockNumber);
+                if (tx == null) {
+                    if (++nullCount > 8) {
+                        clearInterval(interval);
+                    }
+                    return;
+                }
+                if (tx.blockNumber) {
+                    // was mined;
+                    $logger.log(`${hash} Mined`);
+                    clearInterval(interval);
+                    return;
+                }
+                if (++pendingCount > 15) {
+                    clearInterval(interval);
+                    return;
+                }
+            }, 5000)
+        })
+        writer.send({
+            timeout: false
+        })
+
+    }
+    private log(message: string) {
+        this.logger.logTx(this.txWriter.id, message);
+    }
+
+}

package/src/txs/receipt/ITxLogItem.ts

@@ -0,0 +1,25 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { AbiItem } from 'web3-utils';
+
+export interface ITxLogItem {
+    contract: TAddress
+    name: string
+    arguments: {
+        name?: string
+        value: any
+    }[],
+}
+
+export interface ITxLogItemDescriptor {
+    abi: AbiItem
+    formatter: IKnownLogFormatter
+}
+export interface IKnownLogFormatter<TLogFormatted = any> {
+    extract (log: ITxLogItem, platform: TPlatform): Promise<TLogFormatted>
+}
+
+export interface IAbiItemFormattable {
+    abi: AbiItem | string
+    formatter: IKnownLogFormatter
+}

package/src/txs/receipt/TxLogParser.ts

@@ -0,0 +1,29 @@
+import alot from 'alot';
+import { $contract } from '@dequanto/utils/$contract';
+import { TransactionReceipt } from 'web3-core';
+import { TxTopicProvider } from './TxTopicProvider';
+
+
+export class TxLogParser {
+
+
+    constructor (
+        public topics: TxTopicProvider = new TxTopicProvider()
+    ) {
+
+    }
+
+    async parse (receipt: TransactionReceipt) {
+        let logs = await alot(receipt.logs).mapAsync(async log => {
+            let topic = await this.topics.get(log.topics[0]);
+            if (topic == null) {
+                return null;
+            }
+            let { abi, formatter } = topic;
+            let parsed = $contract.parseLogWithAbi(log, abi);
+            return parsed;
+        }).toArrayAsync();
+
+        return logs;
+    }
+}

package/src/txs/receipt/TxLogsTransfer.ts

@@ -0,0 +1,61 @@
+import alot from 'alot';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TokensServiceFactory } from '@dequanto/tokens/TokensServiceFactory';
+import { TransactionReceipt } from 'web3-core';
+import { TxWriter } from '../TxWriter';
+import { IKnownLogFormatter, ITxLogItem } from './ITxLogItem';
+import { TxLogParser } from './TxLogParser';
+
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+
+export interface ITxLogsTransferData {
+    token: IToken
+    from: TAddress
+    to: TAddress
+    amount: bigint
+}
+export class TxLogsTransfer implements IKnownLogFormatter {
+    async extractFromWriter (writer: TxWriter): Promise<ITxLogsTransferData[]> {
+        let receipt = await writer.onCompleted;
+        let knownLogs = writer.tx?.knownLogs ?? [];
+        return this.extractFromParsed(knownLogs, writer.client.platform);
+    }
+
+    async extractFromParsed(knownLogs: ITxLogItem[], platform: TPlatform): Promise<ITxLogsTransferData[]> {
+
+        let transfers = knownLogs.filter(x => x.name === 'Transfer');
+        let tokenService = TokensServiceFactory.get(platform);
+        return alot(transfers).mapAsync(async transfer => {
+            let erc20Address = transfer.contract;
+            let token = await tokenService.getTokenOrDefault(erc20Address);
+            let [ from, to, amount ] = transfer.arguments;
+            return {
+                token,
+                from: from.value,
+                to: to.value,
+                amount: amount.value
+            };
+        }).toArrayAsync();
+    }
+
+    async extractFromReceipt (receipt: TransactionReceipt, platform: TPlatform): Promise<ITxLogsTransferData[]> {
+        let parser = new TxLogParser();
+        let logs = await parser.parse(receipt);
+        logs = logs.filter(x => x != null);
+        return this.extractFromParsed(logs, platform);
+    }
+
+    async extract (transfer: ITxLogItem, platform: TPlatform): Promise<ITxLogsTransferData> {
+        let tokenService = TokensServiceFactory.get(platform);
+        let erc20Address = transfer.contract;
+        let token = await tokenService.getTokenOrDefault(erc20Address);
+        let [ from, to, amount ] = transfer.arguments;
+        return {
+            token,
+            from: from.value,
+            to: to.value,
+            amount: amount.value
+        };
+    }
+}

package/src/txs/receipt/TxTopicInMemoryProvider.ts

@@ -0,0 +1,45 @@
+import { $abiParser } from '@dequanto/utils/$abiParser';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { AbiItem } from 'web3-utils';
+import { IAbiItemFormattable, IKnownLogFormatter, ITxLogItemDescriptor } from './ITxLogItem';
+
+
+export class TxTopicInMemoryProvider {
+
+    private hash: {
+        [hash: string]: ITxLogItemDescriptor
+    } = Object.create(null);
+
+
+
+    register(mix: string | AbiItem |  IAbiItemFormattable | (string | AbiItem | IAbiItemFormattable)[]): this {
+        if (mix == null) {
+            return this;
+        }
+        if (Array.isArray(mix)) {
+            mix.forEach(x => this.register(x));
+            return this;
+        }
+        let abi: AbiItem | string;
+        let formatter: IKnownLogFormatter;
+        if (typeof mix !== 'string' && 'abi' in mix && 'formatter' in mix) {
+            abi = mix.abi;
+            formatter = mix.formatter;
+        } else {
+            abi = mix;
+        }
+        if (typeof abi === 'string') {
+            abi = $abiParser.parseMethod(abi);
+        }
+        let hash = $abiUtils.getMethodHash(abi);
+        this.hash[hash] = {
+            abi,
+            formatter
+        };
+        return this;
+    }
+
+    async get (topicHash: string): Promise<ITxLogItemDescriptor> {
+        return this.hash[topicHash];
+    }
+}

package/src/txs/receipt/TxTopicProvider.ts

@@ -0,0 +1,29 @@
+import di from 'a-di';
+import { AbiItem } from 'web3-utils';
+import { IAbiItemFormattable, ITxLogItemDescriptor } from './ITxLogItem';
+//import { TxLogsTransfer } from './TxLogsTransfer';
+import { TxTopicInMemoryProvider } from './TxTopicInMemoryProvider';
+
+export class TxTopicProvider {
+
+    default = new TxTopicInMemoryProvider();
+
+    constructor () {
+        this.register([
+            'event Transfer(address from, address to, uint256 amount)'
+            // {
+            //     abi: 'event Transfer(address from, address to, uint256 amount)',
+            //     formatter: di.resolve(TxLogsTransfer)
+            // }
+        ]);
+    }
+
+    async get (topicHash: string): Promise<ITxLogItemDescriptor> {
+        return this.default.get(topicHash);
+    }
+
+    register (mix: string | AbiItem |  IAbiItemFormattable | (string | AbiItem | IAbiItemFormattable)[]): this {
+        this.default.register(mix);
+        return this;
+    }
+}

package/src/utils/$abiParser.ts

@@ -0,0 +1,179 @@
+import { AbiItem, AbiOutput } from 'web3-utils';
+
+interface IParameter {
+    name?: string
+    type?: string
+    components?: IParameter[]
+}
+export namespace $abiParser {
+    export function getReturnType (abi: AbiItem): 'array' | 'object' | 'uint256' | 'boolean' | 'buffer' | string {
+        let outputs = abi.outputs;
+        if (outputs == null || outputs.length == 0) {
+            return 'uint256';
+        }
+        if (outputs.length === 1 && !outputs[0].name) {
+            return outputs[0].type;
+        }
+        let hasKeys = outputs.every(x => Boolean(x.name));
+        if (hasKeys) {
+            return 'object';
+        }
+        return 'array';
+    }
+    export function getReturnTypeFromTypes (outputs: AbiOutput[]): 'array' | 'object' | 'uint256' | 'boolean' | 'buffer' | string {
+        if (outputs == null || outputs.length == 0) {
+            return 'uint256';
+        }
+        if (outputs.length === 1 && !outputs[0].name) {
+            return outputs[0].type;
+        }
+        let hasKeys = outputs.every(x => Boolean(x.name));
+        if (hasKeys) {
+            return 'object';
+        }
+        return 'array';
+    }
+
+    const methodRgx = /^((?<type>function|event)\s+)?(?<methodName>\w+)\s*\((?<params>[^)]+)?\)\s*((:|returns)(?<return>.+))?$/;
+
+    /**
+     *  foo(uint256):address
+     *  function foo(uint256): (address account, uint256 value)
+     *  function foo(uint256) returns (address)
+     */
+    export function parseMethod (methodAbi: string): AbiItem {
+        let outputs: IParameter[];
+
+
+        let match = methodRgx.exec(methodAbi);
+        if (match == null) {
+            throw new Error(`Invalid method abi ${methodAbi}. Expect like 'foo(uint256):address'`);
+        }
+
+        let fnName = match.groups.methodName;
+        let $return = match.groups.return?.trim() ?? 'uint256';
+
+        outputs = parseArguments($return);
+
+        let inputs = Parse.parametersLine(match.groups.params ?? '')
+
+        return <AbiItem> {
+            constant: false,
+            payable: false,
+            //"stateMutability": "view",
+
+            name: fnName,
+            inputs: inputs,
+            outputs: outputs,
+            type: match.groups.type ?? 'function',
+        };
+    }
+
+    // uint256
+    // address[]
+    // (uint256, uint256)
+    // (uint256 foo, uint256 bar)
+    // (uint256 foo, uint256 bar)[]
+    export function parseArguments (line: string) {
+        line = line?.trim();
+
+        if (!line || line === '()') {
+            return [];
+        }
+        let c = line[0];
+        if (c === '{') {
+            throw new Error(`${line} is not supported, use (...) or [...] declarations`);
+        }
+
+
+        if (c === '[' || c === '(') {
+            let end = Parse.goToClosing(line, 0, c);
+            let parametersLine = line.substring(1, end);
+            let isArray = line.endsWith('[]');
+
+            let params = Parse.parametersLine(parametersLine);
+            let isTuple = params.every(x => Boolean(x.name));
+            if (isTuple && isArray) {
+                return [
+                    {
+                        name: '',
+                        type: `tuple[]`,
+                        components: params
+                    }
+                ];
+            }
+
+            if (params.length === 1) {
+                line = params[0].type;
+
+                params = [
+                    {
+                        name: "",
+                        type: line,
+                    },
+                ];
+            }
+
+            return params;
+        }
+
+        // if (c === '{') {
+        //     let params = line.substring(1, line.length - 1);
+
+        //     outputs = params.split(',').map(x => x.trim()).map(param => {
+        //         let [_type, _name] = param.split(/[\s+:]/).map(x => x.trim()).filter(Boolean);
+
+        //         return {
+        //             name: _name ?? '',
+        //             type: _type.trim()
+        //         };
+        //     });
+        // }
+        return [
+            {
+                name: '',
+                type: line,
+            },
+        ];
+    }
+}
+
+namespace Parse {
+    // uint256 foo, uint bar, address qux
+    export function parametersLine (paramsStr: string) {
+        return paramsStr
+            .split(',')
+            .map(x => x.trim())
+            .filter(Boolean)
+            .map(param => {
+                let [_type, _name] = param.split(/\s+/).map(x => x.trim()).filter(Boolean);
+                return {
+                    name: _name ?? '',
+                    type: _type.trim()
+                };
+            });
+    }
+
+
+    export function goToClosing (str: string, startI: number, openChar: string, closeChar?: string) {
+        closeChar = closeChar ?? CLOSE_CHARS[openChar];
+        let count = 0;
+        for (let i = startI; i < str.length; i++) {
+            if (str[i] === openChar) {
+                count++;
+            }
+            if (str[i] === closeChar) {
+                count--;
+            }
+            if (count === 0) {
+                return i;
+            }
+        }
+        throw new Error(`Unmatched closing chars ${openChar} ${closeChar} in ${str}`);
+    }
+
+    const CLOSE_CHARS = {
+        '[': ']',
+        '(': ')'
+    };
+}

package/src/utils/$abiType.ts

@@ -0,0 +1,85 @@
+import alot from 'alot';
+
+export namespace $abiType {
+
+    export function getTsType ($abiType: string, $abi?: { type, name, components? }) {
+        let rgxArray = /\[(?<size>\d+)?\]$/
+        let isArray = rgxArray.test($abiType);
+
+        // fix subarrays
+        let rgxSubType = /\[\]\[\d+\]$/
+        if (rgxSubType.test($abiType)) {
+            $abiType = $abiType.replace(rgxSubType, '');
+        }
+
+        let abiType = isArray
+            ? $abiType.replace(rgxArray, '')
+            : $abiType;
+
+        let tsType = AbiTsTypes[abiType];
+        if (tsType == null) {
+            let byRgx = alot(AbiTsTypesRgx).map(definition => ({ match: definition.rgx.exec(abiType), definition })).first(x => x.match != null);
+            if (byRgx) {
+                let { match, definition } = byRgx;
+                tsType = definition.fromMatch?.(match) ?? definition.type;
+            }
+        }
+
+        if (tsType == null && abiType === 'tuple') {
+            let components = $abi?.components as { type, name }[];
+            if (components == null) {
+                throw new Error(`Components undefined for tuple ${$abi?.name ?? ''}`);
+            }
+            let fields = components.map(x => {
+                return `${x.name}: ${getTsType(x.type, x)}`;
+            }).join(', ');
+            tsType = `{ ${fields} }`;
+        }
+
+        if (tsType == null) {
+            throw new Error(`Unknown abi type in return: ${abiType}`);
+        }
+
+        return isArray
+            ? `${tsType}[]`
+            : `${tsType}`;
+    }
+
+
+
+    const AbiTsTypes = {
+        'uint': 'number',
+        'int': 'number',
+
+        'bool': 'boolean',
+
+        'bytes': 'TBufferLike',
+        'bytes4': 'TBufferLike',
+        'bytes32': 'TBufferLike',
+        'bytes64': 'TBufferLike',
+        'bytes128': 'TBufferLike',
+        'bytes256': 'TBufferLike',
+
+        'address': 'TAddress',
+        'string': 'string',
+    };
+    const AbiTsTypesRgx = [
+
+        {
+            rgx: /u?int(?<bits>\d+)/,
+            fromMatch (match: RegExpMatchArray) {
+                let bits = Number(match.groups.bits);
+                if (bits > 64) {
+                    return 'bigint';
+                }
+                return 'number';
+            },
+            type: null,
+        },
+
+        // {
+        //     rgx: /uint\d+/,
+        //     type: 'bigint',
+        // }
+    ];
+}

package/src/utils/$abiUtils.ts

@@ -0,0 +1,38 @@
+import { AbiItem } from 'web3-utils';
+import { AbiCoder }  from '@ethersproject/abi';
+import { $contract } from './$contract';
+import Web3 from 'web3';
+
+export namespace $abiUtils {
+
+    export function encodePacked (...args: any[]) {
+        return Web3.utils.encodePacked(...args);
+    }
+
+    export function encode (types: any[], values: any[]) {
+        let coder = new AbiCoder();
+        return coder.encode(types, values)
+    }
+
+    /** Returns complete method/event hash */
+    export function getMethodHash (abi: AbiItem) {
+        let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
+        let signature = `${abi.name}(${types.join(',')})`;
+        let hash = $contract.keccak256(signature);
+        return hash;
+    }
+
+    export function getMethodSignature (abi: AbiItem) {
+        let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
+        let signature = `${abi.name}(${types.join(',')})`;
+        let hash = $contract.keccak256(signature);
+        return hash.substring(0, 10);
+    }
+    function serializeMethodSignatureArgumentType (input: AbiItem['inputs'][0]) {
+        if (input.type === 'tuple') {
+            let types = input.components.map(x => serializeMethodSignatureArgumentType(x));
+            return `(${types.join(',')})`;
+        }
+        return input.type;
+    }
+}

package/src/utils/$address.ts

@@ -0,0 +1,37 @@
+import { TAddress } from '@dequanto/models/TAddress';
+
+export namespace $address {
+    export function eq (a1: string, a2: string) {
+        return a1?.toUpperCase() === a2?.toUpperCase();
+    }
+
+    export function find<T> (arr: T[], getter: (x: T) => TAddress, address: TAddress) {
+        return arr.find(x => eq(getter(x), address));
+    }
+
+    export function isValid (address: TAddress) {
+        let rgx = /0x[\dA-F]{40,}/i;
+        return rgx.test(address);
+    }
+    export function isEmpty (address: TAddress) {
+        if (address == null || address === '') {
+            return true;
+        }
+        if (/^0x0+$/.test(address)) {
+            return true;
+        }
+        return false;
+    }
+    export function expectValid (address: TAddress, message: string) {
+        if (isValid(address) === false) {
+            throw new Error(`${address} is invalid: ${message}`);
+        }
+        return address;
+    }
+
+    export function toBytes32 (address: TAddress) {
+        return address.toLowerCase().substring(2).padStart(32, '0');
+    }
+
+    export const ZERO = '0x0000000000000000000000000000000000000000'
+}