dequanto 0.0.1

package/src/gen/GeneratorFromAbi.ts

@@ -0,0 +1,402 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { AbiItem } from 'web3-utils';
+import { File } from 'atma-io';
+import { class_Uri } from 'atma-utils';
+import alot from 'alot';
+import { $abiType } from '@dequanto/utils/$abiType';
+import { $date } from '@dequanto/utils/$date';
+import { $path } from '@dequanto/utils/$path';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { TPlatform } from '@dequanto/models/TPlatform';
+
+export class GeneratorFromAbi {
+
+    static get Gen () {
+        return Gen;
+    }
+
+    async generate (abiJson: AbiItem[], opts: {
+        network: TPlatform
+        name: string
+        address: TAddress
+        output: string
+        implementation: TAddress
+        saveAbi?: boolean
+        sources?: {
+            [file: string]: { content: string }
+        }
+    }) {
+
+        let methodsArr = abiJson
+            .map(item => {
+                if (item.type === 'function') {
+                    return Gen.serializeMethodTs(item);
+                }
+                return null;
+            })
+            .filter(Boolean)
+            .map(Str.formatMethod);
+            ;
+
+        let eventsArr = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEvent(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+            ;
+        let eventsExtractorsArr = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEventExtractor(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+
+        let eventInterfaces = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEventInterface(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+            ;
+
+        let methods = methodsArr.join('\n\n');
+        let events = eventsArr.join('\n\n');
+        let eventsExtractors = eventsExtractorsArr.join('\n\n');
+
+        let name = opts.name;
+        let templatePath = $path.resolve(`/src/gen/ContractTemplate.ts`);
+        let template = await File.readAsync<string>(templatePath, { skipHooks: true });
+
+        let EtherscanStr;
+        let EthWeb3ClientStr;
+        let imports = [];
+        let explorerUrl: string;
+        switch (opts.network) {
+            case 'bsc':
+                EtherscanStr = 'Bscscan';
+                EthWeb3ClientStr = 'BscWeb3Client';
+                imports = [
+                    `import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan'`,
+                    `import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client'`,
+                ];
+                explorerUrl = `https://bscscan.com/address/${opts.implementation}#code`;
+                break;
+            case 'polygon':
+                EtherscanStr = 'Polyscan';
+                EthWeb3ClientStr = 'PolyWeb3Client';
+                imports = [
+                    `import { Polyscan } from '@dequanto/BlockchainExplorer/Polyscan'`,
+                    `import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client'`,
+                ];
+                explorerUrl = `https://polygonscan.com/address/${opts.implementation}#code`;
+                break;
+            case 'xdai':
+                EtherscanStr = 'XDaiscan';
+                EthWeb3ClientStr = 'XDaiWeb3Client';
+                imports = [
+                    `import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan'`,
+                    `import { XDaiWeb3Client } from '@dequanto/chains/xdai/XDaiWeb3Client'`,
+                ];
+                explorerUrl = `https://blockscout.com/xdai/mainnet/address/${opts.implementation}/contracts`;
+                break;
+            case 'eth':
+                EtherscanStr = 'Etherscan';
+                EthWeb3ClientStr = 'EthWeb3Client';
+                imports = [
+                    `import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan'`,
+                    `import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'`,
+                ];
+                explorerUrl = `https://etherscan.io/address/${opts.implementation}#code`;
+                break;
+            default:
+                throw new Error(`Unknown network ${opts.network}`);
+        }
+
+        let code = template
+            .replace(/\$Etherscan\$/g, EtherscanStr)
+            .replace(/\$EthWeb3Client\$/g, EthWeb3ClientStr)
+            .replace(`/* IMPORTS */`, imports.join('\n'))
+            .replace(`$NAME$`, Gen.toClassName(name))
+            .replace(`$ADDRESS$`, opts.address ?? '')
+            .replace(`/* METHODS */`, methods)
+            .replace(`/* EVENTS */`, events)
+            .replace(`/* EVENTS_EXTRACTORS */`, eventsExtractors)
+            .replace(`$ABI$`, JSON.stringify(abiJson))
+            .replace(`$DATE$`, $date.format(new Date(), 'yyyy-MM-dd HH:mm'))
+            .replace(`$EXPLORER_URL$`, explorerUrl)
+            .replace(`/* $EVENT_INTERFACES$ */`, eventInterfaces.join('\n'))
+            ;
+
+
+        let directory = name;
+        let filename = /[^\\/]+$/.exec(name)[0];
+
+        let path = class_Uri.combine(opts.output, directory, `${filename}.ts`);
+        await File.writeAsync(path, code, { skipHooks: true });
+
+        if (opts.saveAbi) {
+            let path = class_Uri.combine(opts.output, directory, `${filename}.json`);
+            await File.writeAsync(path, abiJson);
+        }
+
+        console.log(`ABI wrapper class created: ${path}`);
+
+        let sources = opts.sources;
+        let sourceFiles = [];
+        if (sources) {
+            sourceFiles = await alot.fromObject(sources).mapAsync(async entry => {
+                let sourceFilename = /\/?([^/]+$)/.exec(entry.key)[1];
+                let path = class_Uri.combine(opts.output, directory, filename, sourceFilename);
+                await File.writeAsync(path, entry.value.content, { skipHooks: true });
+
+                console.log(`Source code saved: ${path}`);
+                return path;
+            }).toArrayAsync();
+        }
+        return {
+            main: path,
+            sources: sourceFiles,
+        };
+    }
+}
+
+
+namespace Gen {
+
+    export function toClassName (name: string) {
+        let str = name.replace(/[^\w_\-\\/]/g, '');
+        str = str.replace(/[\-\\/](\w)/g, (full, letter) => {
+            return letter.toUpperCase();
+        });
+        return str[0].toUpperCase() + str.substring(1);
+    }
+
+
+    export function serializeMethodTs (abi: AbiItem) {
+        let isRead = isReader(abi);
+        if (isRead) {
+            return serializeReadMethodTs(abi);
+        }
+        return serializeWriteMethodTs(abi);
+    }
+
+    export function serializeEvent (abi: AbiItem) {
+        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        return `
+            on${abi.name} (fn: (event: EventData, ${fnInputArguments}) => void): ClientEventsStream<any> {
+                return this.$on('${abi.name}', fn);
+            }
+        `;
+    }
+    export function serializeEventExtractor (abi: AbiItem) {
+        return `
+            extractLogs${abi.name} (tx: TransactionReceipt): TLog${abi.name}[] {
+                let abi = this.$getAbiItem('event', '${abi.name}');
+                return this.$extractLogs(tx, abi) as any as TLog${abi.name}[];
+            }
+        `;
+    }
+    export function serializeEventInterface (abi: AbiItem) {
+        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        return `
+            type TLog${abi.name} = {
+                contract: TAddress,
+                ${fnInputArguments}
+            }
+        `;
+    }
+
+    export function isReader (abi: AbiItem) {
+        return ['view', 'pure', null].includes(abi.stateMutability);
+    }
+
+    export function serializeMethodAbi(abi: AbiItem, includeNames?: boolean) {
+        let params = abi.inputs?.map(x => {
+            let param = x.type;
+            if (includeNames && x.name) {
+                param += ' ' + x.name;
+            }
+            return param;
+        }).join(', ') ?? '';
+        let returns = serializeMethodAbiReturns(abi.outputs);
+        if (returns && abi.outputs.length > 1) {
+            returns = `(${returns})`;
+        }
+        let returnsStr = returns ? `returns ${returns}` : '';
+        return `function ${abi.name}(${params}) ${returnsStr}`.trim();
+    }
+
+    function serializeReadMethodTs (abi: AbiItem) {
+        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        if (callInputArguments) {
+            callInputArguments = `, ${callInputArguments}`;
+        }
+        return `
+            // ${$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (${fnInputArguments}): ${fnResult} {
+                return this.$read('${serializeMethodAbi(abi)}'${callInputArguments});
+            }
+        `;
+    }
+
+    function serializeWriteMethodTs (abi: AbiItem) {
+        let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
+        if (callInputArguments) {
+            callInputArguments = `, ${callInputArguments}`;
+        }
+
+        return `
+            // ${$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (eoa: {address: TAddress, key: string, value?: string | number | bigint }, ${fnInputArguments}): Promise<TxWriter> {
+                return this.$write(this.$getAbiItem('function', '${abi.name}'), eoa${callInputArguments});
+            }
+        `;
+    }
+
+    function serializeArgumentsTs (abi: AbiItem) {
+        let inputs = abi.inputs.map((input, i) => {
+            let result = { ...input };
+            if (result.name == null || result.name === '') {
+                result.name = 'input' + i;
+            }
+            return result;
+        });
+
+        let fnInputArguments = inputs
+            ?.map((input) => {
+                let tsType = $abiType.getTsType(input.type, input);
+                if (tsType == null) {
+                    throw new Error(`Unknown abi type in arguments: ${input.type}`);
+                }
+
+                return `${input.name}: ${tsType}`;
+            })
+            ?.join(', ') ?? '';
+
+        let callInputArguments = inputs
+            ?.map(input => {
+                return `${input.name}`;
+            })
+            ?.join(', ') ?? '';
+
+
+        let fnResult = serializeMethodTsReturns(abi.outputs);
+        return { fnInputArguments, callInputArguments, fnResult };
+    }
+
+    function isObjectParams (params: { name, type }[]) {
+        return params?.every(x => Boolean(x.name));
+    }
+    function serializeMethodAbiReturns (params: { name, type, components? }[]) {
+        if (params == null) {
+            return '';
+        }
+        // if (isObjectParams(params)) {
+        //     return params.map(x => serializeMethodAbiReturnsSingle(x)).join(',');
+        // }
+        return params?.map(x => serializeMethodAbiReturnsSingle(x)).join(',');
+    }
+    function serializeMethodAbiReturnsSingle (param: { name, type, components? }) {
+        if (param == null) {
+            return null;
+        }
+        if (param.components) {
+            // tuple, tuple[]
+            let fields = serializeMethodAbiReturns(param.components);
+            return `[${fields}]${ param.type === 'tuple[]' ? '[]' : '' }`;
+        }
+        // if (param.name && param.type) {
+        //     return `${param.type} ${param.name}`;
+        // }
+        return param.type;
+    }
+    function serializeMethodTsReturns (params: { name, type }[]) {
+        if (params == null || params.length === 0) {
+            params = [ { name: '', type: 'uint256' } ];
+        }
+
+        let tsTypes = params.map(param => {
+            let tsType = $abiType.getTsType(param.type, param);
+            if (tsType == null) {
+                throw new Error(`(gen) Unknown abi type in return: ${param.type}`);
+            }
+            return {
+                name: param.name,
+                type: tsType
+            };
+        });
+
+        if (params.length > 1 && isObjectParams(params)) {
+            let paramsStr = tsTypes.map(x => `${x.name}: ${x.type}`).join(', ');
+            return `Promise<{ ${paramsStr} }>`;
+        }
+
+        let fnResult = tsTypes?.map(x => x.type).join(', ');
+        if (tsTypes.length > 1) {
+            fnResult = `[ ${fnResult} ]`
+        }
+        return `Promise<${fnResult}>`;
+    }
+
+
+    // const AbiTsTypes = {
+    //     'uint8': 'number',
+    //     'uint4': 'number',
+    //     'uint': 'number',
+
+    //     'bool': 'boolean',
+
+    //     'bytes': 'Buffer',
+    //     'bytes4': 'Buffer',
+    //     'bytes32': 'Buffer',
+    //     'bytes64': 'Buffer',
+    //     'bytes128': 'Buffer',
+    //     'bytes256': 'Buffer',
+
+    //     'address': 'TAddress',
+    //     'string': 'string',
+    // };
+    // const AbiTsTypesRgx = [
+    //     {
+    //         rgx: /uint\d+/,
+    //         type: 'bigint',
+    //     }
+    // ];
+}
+
+
+namespace Str {
+    export function formatMethod (str: string) {
+        str = trim(str);
+        str = indent(str, '    ');
+        return str;
+    }
+    export function trim (str: string) {
+        let lines = str.split('\n');
+        let min = alot(lines).min(x => {
+            if (x.trim() === '') {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            let match = /^\s+/.exec(x);
+            if (match == null) {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            return match[0].length;
+        });
+
+        lines = lines.map((line, i) => {
+            let x = line.substring(min);
+            if ((i === 0) || (lines.length === i + 1)) {
+                if (x === '') {
+                    return null;
+                }
+            }
+            return x;
+        }).filter(Boolean);
+        return lines.join('\n');
+    }
+    export function indent (str: string, indent: string) {
+        return str
+            .split('\n')
+            .map(x => `${indent}${x}`)
+            .join('\n');
+    }
+}

package/src/handlers/TokenHandler.ts

@@ -0,0 +1,78 @@
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { PlatformFactory } from '@dequanto/chains/PlatformFactory';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $is } from '@dequanto/utils/$is';
+import { $require } from '@dequanto/utils/$require';
+import di from 'a-di';
+import memd from 'memd';
+
+export class TokenHandler {
+    constructor(public platform: TPlatform) {
+
+    }
+
+    async transfer (params: {
+        from: TAddress | ChainAccount
+        to: TAddress
+        token: string | IToken
+        amount: number
+        internal?: boolean
+    }) {
+
+
+        let fromAccount:ChainAccount = await this.getAccount(params.from, true);
+        let toAccount = await this.getAccount(params.to, params.internal);
+
+        let chain = await this.chain();
+
+        let token = typeof params.token === 'string'
+            ? await chain.tokens.getKnownToken(params.token)
+            : params.token;
+
+        $require.Token(token);
+        $require.notNull(fromAccount, 'FromAccount');
+        $require.notNull(toAccount, 'ToAccount');
+
+        let amountEther = params.amount;
+        if (amountEther == Infinity) {
+            let balance = await chain.transfer.getBalance(fromAccount.address, token);
+            amountEther = $bigint.toEther(balance, token.decimals);
+        }
+        console.log('Transfering: ', amountEther, token.symbol);
+
+        let service = chain.transfer
+            .$config({
+                type: 2
+                //gasFunding: ChainAccountProvider.get(PLATFORM, 'quant')
+            });
+
+        let txToken = params.amount === Infinity
+                ? await service.transferAll(fromAccount, toAccount.address, token)
+                : await service.transfer(fromAccount, toAccount.address, token, params.amount);
+
+        return txToken;
+    }
+
+    @memd.deco.memoize({ perInstance: true })
+    private chain () {
+        return di.resolve(PlatformFactory).get(this.platform);
+    }
+
+    private async getAccount(mix: string | TAddress | ChainAccount, isPrivate?: boolean) {
+        if (typeof mix === 'object' && 'address' in mix && 'key' in mix) {
+            return mix;
+        }
+        let chain = await this.chain();
+        let account = await chain.accounts.get(mix);
+        if (account == null) {
+            if (isPrivate !== false) {
+                throw new Error(`Account ${mix} not found`);
+            }
+            return { address: mix } as any as ChainAccount;
+        }
+        return account;
+    }
+}

package/src/indexer/BlocksTxIndexer.ts

@@ -0,0 +1,69 @@
+import { BlockTransactionString } from 'web3-eth';
+import { Transaction } from 'web3-core';
+import { BlocksWalker } from './handlers/BlocksWalker';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { $logger } from '@dequanto/utils/$logger';
+
+
+export interface IBlocksTxIndexerOptions {
+    /** Name of the indexer */
+    name?: string
+    persistance?: boolean
+    loadTransactions?: boolean
+}
+export type TBlockListener = (client: Web3Client, block: BlockTransactionString, txs?: Transaction[]) => Promise<void>
+
+export class BlocksTxIndexer {
+    private client: Web3Client;
+    private walker: BlocksWalker;
+    private listeners: TBlockListener[] = [];
+
+    constructor (public platform: TPlatform, public opts?: IBlocksTxIndexerOptions) {
+
+        this.client = Web3ClientFactory.get(platform, {
+            ws: true
+        });
+        this.walker = new BlocksWalker({
+            name: `${opts?.name ?? 'indexer'}_${this.platform}`,
+            client: this.client,
+            loadTransactions: opts?.loadTransactions ?? true,
+            persistance: opts?.persistance ?? true,
+            visitor: async (block, txs) => {
+                return this.indexTransactions(block, txs)
+            }
+        });
+    }
+
+    public onBlock (cb: TBlockListener): this {
+        this.listeners.push(cb);
+        return this;
+    }
+
+    public stats () {
+        return this.walker.stats();
+    }
+
+    async start (from?: Date | number, to?: Date | number) {
+        await this.walker.start(from, to);
+
+        if (to == null) {
+            this.client.subscribe('newBlockHeaders', (error, blockHeader) => {
+                this.walker.processUntil(blockHeader.number);
+            });
+        }
+    }
+
+    private async indexTransactions (block: BlockTransactionString, txs: Transaction[]) {
+        for (let i = 0; i < this.listeners.length; i++) {
+            let indexer = this.listeners[i];
+            try {
+                await indexer(this.client, block, txs);
+            } catch (error) {
+                $logger.log(error);
+            }
+        }
+    }
+}
+

package/src/indexer/PendingTxIndexer.ts

@@ -0,0 +1,124 @@
+import { BlockTransactionString } from 'web3-eth'
+import { Transaction } from 'web3-core';
+import { BlocksWalker } from './handlers/BlocksWalker';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { TxQueueLoader } from './handlers/TxQueueLoader';
+import { BlocksTxIndexer } from './BlocksTxIndexer';
+import { $number } from '@dequanto/utils/$number';
+
+
+export interface IPendingTxIndexerOptions {
+    /** Name of the indexer */
+    name?: string
+}
+export type TPendingTxListener = (client: Web3Client, tx: Transaction) => Promise<void>
+
+export class PendingTxIndexer {
+
+    private client: Web3Client;
+    private walker: BlocksWalker;
+    private listeners: TPendingTxListener[] = [];
+
+    //private mempool = [];
+    private mempoolHash = Object.create(null);
+
+    private loader: TxQueueLoader;
+    private blocks: BlocksTxIndexer;
+    private status = {
+        startedAt: null as number,
+        // ~ tx/s
+        txSpeed: 0,
+
+        txCount: 0,
+        txNulls: 0,
+
+        // tx not seen in mempool
+        txPrivateCount: 0,
+    }
+
+    constructor (public platform: TPlatform, public opts?: IPendingTxIndexerOptions) {
+
+        this.client = Web3ClientFactory.get(platform, {
+            ws: true
+        });
+
+
+        let pool = Web3ClientFactory.get(platform);
+        this.loader = new TxQueueLoader(pool, tx => {
+            this.onMempoolTxLoaded(tx);
+        });
+        this.blocks = new BlocksTxIndexer(platform, {
+            name: opts.name,
+            loadTransactions: false,
+            persistance: false,
+        });
+        this.blocks.onBlock(async (client, block) => {
+            this.onBlockLoaded(block);
+        });
+    }
+
+    public onTransaction (cb: TPendingTxListener): this {
+        this.listeners.push(cb);
+        return this;
+    }
+
+    public stats () {
+        if (this.status.startedAt == null) {
+            return { active: false }
+        }
+        let seconds = (Date.now() - this.status.startedAt) / 1000 | 0;
+        let txSpeed = $number.round(this.status.txCount / seconds, 2);
+        return {
+            active: true,
+            txSpeed: txSpeed,
+            ...this.status,
+            loader: {
+                ...this.loader.stats()
+            },
+            blocks: {
+                ...this.blocks.stats()
+            },
+        }
+    }
+
+    async start () {
+        this.status.startedAt = Date.now();
+        this.client.subscribe('pendingTransactions', (error, hash) => {
+            this.status.txCount++;
+            this.mempoolHash[hash] = 1;
+            this.loader.push(hash);
+        });
+
+        let blockNumber = await this.client.getBlockNumber();
+        this.blocks.start(blockNumber);
+    }
+
+
+    private onMempoolTxLoaded (tx: Transaction) {
+        if (tx == null) {
+            this.status.txNulls++;
+            return;
+        }
+        for (let i = 0; i < this.listeners.length; i++) {
+            this.listeners[i](this.client, tx);
+        }
+    }
+    private onBlockLoaded (block: BlockTransactionString) {
+        for (let i = 0; i < block.transactions.length; i++) {
+            let hash = block.transactions[i];
+
+            if (hash in this.mempoolHash) {
+                delete this.mempoolHash[hash];
+                continue;
+            }
+            //Not seen in memhash;
+            this.status.txPrivateCount++;
+            this.status.txCount++;
+            this.mempoolHash[hash] = 1;
+            this.loader.push(hash);
+        }
+    }
+}
+