dequanto 0.0.1

package/src/contracts/EthContract.ts

@@ -0,0 +1,29 @@
+import di from 'a-di'
+import { ContractReader } from './ContractReader'
+import { Contract, IContractInit } from './Contract'
+import { ContractProvider } from './ContractProvider'
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan'
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'
+
+export class EthContract extends Contract {
+
+    public client = this.opts.client ?? di.resolve(EthWeb3Client);
+    public explorer = this.opts.explorer ?? di.resolve(Etherscan);
+    public runner = di.resolve(ContractReader, this.client);
+    public provider = di.resolve(ContractProvider, this.explorer);
+
+    static async create (name: string, opts?: IContractInit): Promise<EthContract>
+    static async create (address: string, opts?: IContractInit): Promise<EthContract>
+    static async create (mix: string, opts?: IContractInit): Promise<EthContract> {
+
+        let explorer = di.resolve(Etherscan);
+        let contract = Contract.create<EthContract>(mix, {
+
+            Ctor: EthContract,
+            explorer,
+
+            ...(opts ?? {})
+        });
+        return contract;
+    }
+}

package/src/contracts/TxContract.ts

@@ -0,0 +1,43 @@
+import di from 'a-di';
+import alot from 'alot';
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { ITransactionDetails } from '@dequanto/models/ITransactionDetails';
+import { utils } from 'ethers'
+import { TransactionDescription } from 'ethers/lib/utils';
+import { Transaction } from 'web3-core';
+import { ContractProvider } from './ContractProvider';
+
+
+export class TxContract {
+
+    private provider = di.resolve(ContractProvider, this.loader);
+
+    constructor (private loader: IBlockChainExplorer = di.resolve(Etherscan)) {
+
+    }
+
+    async parseTrasaction (tx: Transaction): Promise<TransactionDescription> {
+        const abi = await this.provider.getAbi(tx.to);
+
+        const inter = new utils.Interface(abi);
+        const decodedInput = inter.parseTransaction({
+            data: tx.input,
+            value: tx.value,
+        });
+
+        return decodedInput;
+    }
+
+    async parseTrasactions (arr: Transaction[]): Promise<ITransactionDetails[]> {
+        let mapped = await alot(arr).mapAsync(async tx => {
+            let details = await this.parseTrasaction(tx);
+            return {
+                ...tx,
+                details: details as any
+            };
+        }).toArrayAsync();
+
+        return mapped;
+    }
+}

package/src/contracts/common/ERC20.ts

@@ -0,0 +1,13 @@
+/**
+ * dequanto
+ * name: ERC20Base
+ * platform: polygon
+ * source.abi: ./contracts/abi/erc20.abi.json
+ * output: ./contracts/gen/base/
+ */
+
+import { ERC20Base } from '@dequanto-contracts/gen/base/ERC20Base';
+
+export class ERC20 extends ERC20Base {
+
+}

package/src/contracts/common/ERC20Polygon.ts

@@ -0,0 +1,13 @@
+/**
+ * dequanto
+ * name: ERC20PolygonBase
+ * platform: polygon
+ * source.abi: 0x2791bca1f2de4661ed88a30c99a7a9449aa84174
+ * output: ./contracts/gen/polygon/
+ */
+
+import { ERC20PolygonBase } from '@dequanto-contracts/gen/polygon/ERC20PolygonBase';
+
+export class ERC20Polygon extends ERC20PolygonBase {
+
+}

package/src/contracts/common/PoolPair.ts

@@ -0,0 +1,22 @@
+import di from 'a-di';
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { ContractBase } from '@dequanto/contracts/ContractBase';
+
+export class PoolPair extends ContractBase {
+    abi = null
+
+    constructor(
+        public address: TAddress,
+        public client = di.resolve(EthWeb3Client),
+        public explorer = di.resolve(Etherscan)
+    ) {
+        super(address, client, explorer)
+    }
+
+    async getReserves (): Promise<{reserve0: bigint, reserve1: bigint }> {
+        return await this.$read('getReserves() returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)');
+    }
+
+}

package/src/contracts/utils/AbiDeserializer.ts

@@ -0,0 +1,98 @@
+import { $abiType } from '@dequanto/utils/$abiType';
+import { AbiItem, AbiOutput } from 'web3-utils';
+import { $abiParser } from '../../utils/$abiParser';
+
+export namespace AbiDeserializer {
+
+    type AbiNativeType = string;
+
+    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);
+        }
+        return toType(result, types[0]);
+    }
+
+
+
+    function toType(val, type: AbiOutput) {
+        if (type == null) {
+            return val;
+        }
+        if (typeof val === 'string') {
+            let tsType = $abiType.getTsType(type.type);
+
+            switch (tsType) {
+                case 'bigint':
+                    return BigInt(val);
+                case 'number':
+                    return Number(val);
+            }
+        }
+        if (type.type === 'tuple[]') {
+            if (Array.isArray(val) === false) {
+                throw new Error(`${type.name} tuple[] expects array to deserialize. Got ${val}`);
+            }
+            return val.map(item => {
+                return process(item, type.components);
+            });
+        }
+        return val;
+    }
+
+    function toArray(value: object, types: AbiOutput[]) {
+        value = normalizeArray(value);
+
+        if (Array.isArray(value) === false) {
+            throw new Error(`Array expected of types: ${types.map(x => x.type)}; Got ${value}`);
+        }
+
+        let out = [];
+        for (let i = 0; i < types.length; i++) {
+            out[i] = toType(value[i], types[i]);
+        }
+        return out;
+    }
+    function toObject(value: object, types: AbiOutput[]) {
+        let properties = Object.create(null) as { [key: string]: AbiOutput };
+        types.forEach(type => {
+            properties[type.name] = type;
+        });
+
+        let out = Object.create(null);
+        for (let key in value) {
+            if (/^\d+$/.test(key)) {
+                continue;
+            }
+            let info = properties[key];
+            out[key] = toType(value[key], info);
+        }
+        return out;
+    }
+
+    // { 0: a, 1: b, 2: c } to array
+    function normalizeArray(val) {
+        if (Array.isArray(val)) {
+            return val;
+        }
+        let out = [];
+        let length = 0;
+        let keys = 0;
+        for (let key in val) {
+            if (/^\d+$/.test(key)) {
+                length++;
+                out[Number(key)] = val[key]
+                continue;
+            }
+            keys++;
+        }
+        if (length === 0 && keys > 0) {
+            return val;
+        }
+        return out;
+    }
+}

package/src/contracts/utils/ConvertUtils.ts

@@ -0,0 +1,16 @@
+export namespace ConvertUtils {
+    export function toWei (amount: number | bigint, dec: number | string = 18) {
+        let decimals = BigInt(dec);
+
+        return BigInt(amount) * 10n ** decimals;
+    }
+    export function toEther (amount: number | bigint, dec: number | string = 18) {
+        const round = 100000n;
+        let decimals = BigInt(dec);
+        let val = BigInt(amount) * round / 10n ** decimals;
+        if (val < Number.MAX_SAFE_INTEGER) {
+            return Number(val) / Number(round);
+        }
+        return val / round;
+    }
+}

package/src/contracts/utils/InputDataUtils.ts

@@ -0,0 +1,93 @@
+import { IWeb3Client } from '@dequanto/clients/interfaces/IWeb3Client';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { ethers, utils } from 'ethers';
+import { AbiItem } from 'web3-utils';
+import { $abiParser } from '../../utils/$abiParser';
+
+export namespace InputDataUtils {
+    export function split (inputData: string) {
+        let str = inputData.substring(2);
+        let methodName = str.substring(0, 8);
+        let params = str.substring(8);
+        let args = [];
+        while (params.length > 0) {
+            args.push(params.substring(0, 64));
+            params = params.substring(64);
+        }
+        return {
+            method: methodName,
+            args
+        };
+    }
+
+    export function decode (inputs: AbiItem['inputs'], bytes: string) {
+        let types = inputs.map(x => x.type);
+        let args = utils.defaultAbiCoder.decode(
+            types,
+            bytes
+        );
+        let arr = Array.from(args);
+        return normalizeArgs(arr);
+    }
+    export function decodeParamsWithABI (abi: string | AbiItem, bytes: string): any[] {
+        if (typeof abi === 'string') {
+            abi = $abiParser.parseMethod(abi);
+        }
+        let inputs = abi.inputs;
+        let types = inputs.map(x => x.type);
+        let args = utils.defaultAbiCoder.decode(
+            types,
+            bytes
+        );
+        let arr = Array.from(args);
+        return normalizeArgs(arr);
+    }
+    export function decodeWithABI (IFunctionABI: string | AbiItem, ...params): string {
+        let iface = new ethers.utils.Interface([ IFunctionABI as any ]);
+        let methodName: string;
+
+        if (typeof IFunctionABI === 'string') {
+            methodName = /function \s*(?<methodName>[\w\d_]+)/.exec(IFunctionABI)?.groups?.methodName;
+        } else {
+            methodName = IFunctionABI.name;
+        }
+
+        if (methodName == null) {
+            throw new Error(`Invalid method in ${IFunctionABI}. Expects "function foo(...)"`)
+        }
+        return iface.encodeFunctionData(methodName, params);
+    }
+
+
+    /**
+     * 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 methodName: string;
+
+        if (typeof IFunctionABI === 'string') {
+            methodName = /function \s*(?<methodName>[\w\d_]+)/.exec(IFunctionABI)?.groups?.methodName;
+        } else {
+            methodName = IFunctionABI.name;
+        }
+        if (methodName == null) {
+            throw new Error(`Invalid method in ${IFunctionABI}. Expects "function foo(...)"`)
+        }
+        return iface.encodeFunctionData(methodName, params);
+    }
+
+    export function encodeWithTypes (client: Web3Client, types: any[], paramaters: any[]): string {
+        return client.encodeParameters(types, paramaters);
+    }
+
+    export function normalizeArgs (args: any[]) {
+        return args.map(val => {
+            if (val?._isBigNumber) {
+                return BigInt(val.toString());
+            }
+
+            return val;
+        })
+    }
+}

package/src/contracts/utils/TypeUtils.ts

@@ -0,0 +1,21 @@
+export namespace TypeUtils {
+    export function normalize (args: any[]) {
+        args = Array.from(args);
+
+        for (let i = 0; i < args.length; i++) {
+
+            let val = args[i];
+            if (val == null || typeof val !== 'object') {
+                continue;
+            }
+            if (Array.isArray(val)) {
+                args[i] = normalize(val);
+                continue;
+            }
+            if (val._isBigNumber) {
+                args[i] = BigInt(val.toString());
+            }
+        }
+        return args;
+    }
+}

package/src/defi/OneInch/OneInchRouter.ts

@@ -0,0 +1,13 @@
+/**
+ * dequanto
+ * name: OneInchRouterV3Base
+ * platform: bsc
+ * source.abi: 0x11111112542d85b3ef69ae05771c2dccff4faa26
+ * output: ./contracts/gen/bsc/
+ */
+
+import { OneInchRouterV3Base } from '../../../contracts/gen/bsc/OneInchRouterV3Base';
+
+export class OneInchRouterContract extends OneInchRouterV3Base {
+
+}

package/src/env/BigIntSerializer.ts

@@ -0,0 +1,18 @@
+(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');
+};
+
+(BigInt as any).prototype.valueOf = function () {
+    if (this > BigInt(Number.MAX_VALUE)) {
+        throw new Error(`BigInt to Number overfows: ${this}`)
+    }
+    return Number(this);
+};
+
+export function BigIntSerializer () {}
+

package/src/gen/Ast.ts

@@ -0,0 +1,12 @@
+//import parser from '@solidity-parser/parser';
+
+
+export class Ast {
+
+    static parse (source: string) {
+        // let ast = parser.parse(source, {
+        //     tolerant: true,
+        // });
+
+    }
+}

package/src/gen/ContractTemplate.ts

@@ -0,0 +1,36 @@
+/**
+ *  AUTO-Generated Class: $DATE$
+ *  Implementation: $EXPLORER_URL$
+ */
+import di from 'a-di';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TBufferLike } from '@dequanto/models/TBufferLike';
+import { ClientEventsStream } from '@dequanto/clients/ClientEventsStream';
+import { ContractBase } from '@dequanto/contracts/ContractBase';
+import { AbiItem } from 'web3-utils';
+import { TransactionReceipt } from 'web3-core';
+import { EventData } from 'web3-eth-contract';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+
+/* IMPORTS */
+export class $NAME$ extends ContractBase {
+    constructor(
+        public address: TAddress = '$ADDRESS$',
+        public client: Web3Client = di.resolve($EthWeb3Client$),
+        public explorer: IBlockChainExplorer = di.resolve($Etherscan$)
+    ) {
+        super(address, client, explorer)
+    }
+
+/* METHODS */
+
+/* EVENTS */
+
+/* EVENTS_EXTRACTORS */
+
+    abi = $ABI$
+}
+
+/* $EVENT_INTERFACES$ */

package/src/gen/Generator.ts

@@ -0,0 +1,227 @@
+import di from 'a-di';
+import alot from 'alot';
+import { AbiItem } from 'web3-utils';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { $address } from '@dequanto/utils/$address';
+import { $require } from '@dequanto/utils/$require';
+import { GeneratorFromAbi } from './GeneratorFromAbi';
+import { TAddress } from '@dequanto/models/TAddress';
+import { File, Directory } from 'atma-io';
+import { class_Uri, obj_setProperty } from 'atma-utils';
+import { BlockChainExplorerProvider } from '@dequanto/BlockchainExplorer/BlockChainExplorerProvider';
+import { TPlatform } from '@dequanto/models/TPlatform';
+
+export interface IGenerateOptions {
+    platform: TPlatform
+    name: string
+    defaultAddress?: TAddress
+
+    source: {
+        abi?: TAddress
+        code?: string
+    }
+
+    output?: string
+
+    location?: string
+
+    /**
+     * a) Slot to read the implementation address from
+     * b) The implementation address
+     * c) Method function to read the implementation address from
+     */
+    implementation?: string
+
+    /** ABI will be save alongside with TS classes */
+    saveAbi?: boolean
+}
+const KEYS = {
+    'platform': 1,
+    'name': 1,
+    'defaultAddress': 1,
+    'source.abi': 1,
+    'source.code': 1,
+    'output': 1,
+    'implementation': 1
+};
+
+export class Generator {
+
+    explorer: IBlockChainExplorer;
+
+    constructor (public options: IGenerateOptions) {
+        let {
+            platform,
+        } = options;
+
+        this.explorer = BlockChainExplorerProvider.get(platform);
+
+        if (options.defaultAddress == null && $address.isValid(options.source.abi)) {
+            options.defaultAddress = options.source.abi;
+        }
+    }
+
+    static async generateForClass (path: string) {
+
+        let i = path.indexOf('*');
+        if (i > -1) {
+            let base = path.substring(0, i).replace(/\\/g, '/');
+            let glob = path.substring(i).replace(/\\/g, '/');
+            let files = await Directory.readFilesAsync(base, glob);
+
+            await alot(files)
+                .forEachAsync(async file => {
+                    await this.generateForClass(file.uri.toString());
+                })
+                .toArrayAsync({ threads: 1 });
+            return;
+        }
+
+        let jsCode = await File.readAsync <string> (path, { skipHooks: true });
+        let startIdx = jsCode.indexOf('/*');
+        let endIdx = jsCode.indexOf('*/');
+        if (startIdx === -1 || endIdx === -1) {
+            throw new Error(`${path} should contain dequanto options in comment`);
+        }
+
+        let header = jsCode.substring(startIdx, endIdx);
+        let lines = header.split('\n');
+        let rgxOpts = /(?<key>[\w.]+)\s*:\s*(?<value>[^\n]+)/;
+        let options = {} as IGenerateOptions;
+        for (let line of lines) {
+            let match = rgxOpts.exec(line);
+            if (match == null) {
+                continue;
+            }
+            let key = match.groups.key.trim();
+            let value: any = match.groups.value.trim();
+            if (value === 'true') {
+                value = true;
+            } else if (value === 'false') {
+                value = false;
+            } else if (/^[\d\.]$/.test(value)) {
+                value = Number(value)
+            }
+
+            if (key in KEYS === false) {
+                throw new Error(`Invalid options key ${key}`);
+            }
+
+            obj_setProperty(options, key, value);
+        }
+
+        // make Contracts in dequanto package relative to dequanto root
+        let rgxRoot = /[\\\/]dequanto[\\\/].+/;
+        if (rgxRoot.test(path)) {
+            let root = path.replace(rgxRoot, '/dequanto/');
+            options.output = class_Uri.combine(root, options.output);
+        }
+        let generator = new Generator({
+            ...options,
+            location: new class_Uri(path).toDir().toString()
+        });
+        await generator.generate();
+    }
+
+    async generate () {
+        let { name, platform: network, output, implementation: implSource } = this.options;
+
+        let { abiJson, implementation } = await this.getAbi({ implementation: implSource });
+        let sources = await this.getSources(implementation, name);
+        let generator = di.resolve(GeneratorFromAbi);
+
+        let address = this.options.defaultAddress;
+
+        return await generator.generate(abiJson, {
+            network: network,
+            name: name,
+            address: address,
+            output: output,
+            implementation: implementation,
+            sources: sources,
+            saveAbi: this.options.saveAbi
+        });
+    }
+
+    private async getAbi(opts: { implementation: string }) {
+        let abi = this.options.source.abi;
+        $require.notNull(abi, `Abi not provided to get the Abi Json from`);
+
+        let abiJson: AbiItem[]
+        let implementation: TAddress;
+        if (abi.startsWith('0x')) {
+            let { abi, implementation: impl } = await this.getAbiByAddress(opts);
+            abiJson = abi;
+            implementation= impl;
+        } else {
+            let path = abi;
+            let location = this.options.location;
+            if (location && path[0] !== '/') {
+                // if path not relative, check the file at ClassFile location
+                let relPath = class_Uri.combine(location, path);
+                if (await File.existsAsync(relPath)) {
+                    path = relPath;
+                }
+            }
+            abiJson = await File.readAsync(path);
+        }
+
+        $require.notNull(abiJson, `Abi not resolved from ${abi}`);
+        return { abiJson, implementation };
+    }
+    private async getSources (implementation: TAddress, name: string) {
+        if ($address.isValid(implementation) === false) {
+            return null;
+        }
+
+        console.log('Loading contract source code.');
+        let meta = await this.explorer.getContractSource(implementation);
+        if (meta?.SourceCode == null) {
+            console.log('No contract source found.');
+            return null;
+        }
+        if (/^\s*\{/.test(meta.SourceCode) === false) {
+            console.log('Source contract as single file fetched.');
+            return {
+                [`${name}.sol`]: {
+                    content: meta.SourceCode
+                }
+            };
+        }
+
+        let code = meta
+            .SourceCode
+            .replace(/\{\{/g, '{')
+            .replace(/\}\}/g, '}')
+
+        try {
+            let sources = JSON.parse(code);
+            let files = sources.sources;
+
+            console.log(`Source code (${Object.keys(files).join(', ')}) fetched.`)
+            return files;
+        } catch (error) {
+            console.error(`Source code can't be parsed: `, code);
+            throw new Error(`Source code can't be parsed: ${error.message}`);
+        }
+    }
+
+    private async getAbiByAddress (opts: { implementation: string }) {
+        let address = $address.expectValid(this.options.source?.abi, 'contract address is not valid');
+        let explorer = $require.notNull(this.explorer, `Explorer not resolved for network: ${this.options.platform}`);
+
+        try {
+            console.log(`Loading contracts ABI for ${address}. `)
+            let { abi, implementation } = await explorer.getContractAbi(address, opts);
+
+            let hasProxy = $address.eq(address, implementation) === false;
+            console.log(`Proxy detected: ${hasProxy ? 'YES' : 'NO' }`, hasProxy ? implementation : '');
+
+            let abiJson = JSON.parse(abi) as AbiItem[];
+            return { abi: abiJson, implementation };
+        } catch (error) {
+            console.error(error);
+            throw new Error(`ABI is not resolved from ${this.options.platform}/${address}: ${error.message ?? error}`);
+        }
+    }
+}