dequanto 0.0.1

package/test/generate/class.spec.ts

@@ -0,0 +1,27 @@
+import { Generator } from '@dequanto/gen/Generator';
+import { $path } from '@dequanto/utils/$path';
+import { File } from 'atma-io';
+
+UTest({
+    async 'generate test' () {
+        let genPath = `/test/tmp/polygon/DaiTokenContractBase.ts`
+
+        try {
+            await File.removeAsync(genPath);
+        } catch(e){}
+
+        let existsBase = await File.exists(genPath);
+        eq_(existsBase, false);
+
+        let templatePath = $path.resolve(`/src/gen/ContractTemplate.ts`);
+        let exists = await File.exists(templatePath);
+        eq_(exists, true);
+        await Generator.generateForClass('/test/fixtures/DaiTokenContract.ts');
+
+        existsBase = await File.exists(genPath);
+        eq_(existsBase, true);
+
+        let source = await File.readAsync(genPath, { skipHooks: true });
+        has_(source, 'onTransfer');
+    }
+})

package/test/hardhat/TestNode.ts

@@ -0,0 +1,61 @@
+import memd from 'memd';
+import { HardhatWeb3Client } from '@dequanto/clients/HardhatWeb3Client';
+import { Socket } from 'net';
+import { Shell } from 'shellbee'
+
+const PORT = `8545`;
+const HOST = `http://127.0.0.1:${PORT}/`
+
+export class TestNode {
+    static PORT = PORT
+    static HOST = HOST
+
+    static async client () {
+        await TestNode.start();
+        return HardhatWeb3Client.url(HOST);
+    }
+
+    @memd.deco.memoize()
+    static async start () {
+        if (await isPortBusy(PORT) === false) {
+
+            let shell = await Shell.run({
+                command: 'npx hardhat node',
+                matchReady: /Started HTTP/i
+            });
+            await shell.onReadyAsync();
+        }
+    }
+}
+
+async function isPortBusy(port) {
+
+    return new Promise((resolve, reject) => {
+        const socket = new Socket();
+
+        const timeout = () => {
+            resolve(false);
+            socket.destroy();
+        };
+
+
+        setTimeout(timeout, 500);
+        socket.on("timeout", timeout);
+
+        socket.on("connect", function () {
+            socket.destroy();
+            resolve(true);
+        });
+
+        socket.on("error", function (exception: any) {
+            if (exception.code !== "ECONNREFUSED") {
+                resolve(false);
+            } else {
+                socket.destroy();
+                resolve(true);
+            }
+        });
+
+        socket.connect(port, "127.0.0.1");
+    });
+}

package/test/ns.spec.ts

@@ -0,0 +1,30 @@
+import { EnsProvider } from '@dequanto/ns/providers/EnsProvider'
+import { UDProvider } from '@dequanto/ns/providers/UDProvider';
+import { $ns } from '@dequanto/ns/utils/$ns';
+
+UTest({
+
+
+    'ens': {
+        async 'namehash' () {
+            let hash = $ns.namehash('alice.eth');
+            eq_(hash, `0x787192fc5378cc32aa956ddfdedbf26b24e8d78e40109add0eea2c1a012c3dec`);
+        },
+        async 'address' () {
+            let ens = new EnsProvider()
+            let addr = await ens.getAddress('alice.eth');
+            eq_(addr, `0xcd2E72aEBe2A203b84f46DEEC948E6465dB51c75`);
+        }
+    },
+    'ud': {
+        async 'namehash' () {
+            let hash = $ns.namehash('brad.crypto');
+            eq_(hash, `0x756e4e998dbffd803c21d23b06cd855cdc7a4b57706c95964a37e24b47c10fc9`);
+        },
+        async 'address' () {
+            let ens = new UDProvider()
+            let addr = await ens.getAddress('brad.crypto');
+            eq_(addr?.toLowerCase(), `0x8aad44321a86b170879d7a244c1e8d360c99dda8`);
+        }
+    }
+})

package/test/receipt.spec.ts

@@ -0,0 +1,27 @@
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { TxLogParser } from '@dequanto/txs/receipt/TxLogParser'
+import { TxLogsTransfer } from '@dequanto/txs/receipt/TxLogsTransfer';
+import di from 'a-di';
+import { File } from 'atma-io'
+import { TransactionReceipt } from 'web3-core';
+
+const tx = {
+    swap: `0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a`
+};
+
+UTest({
+    async '//download' () {
+        let receipt = await di.resolve(EthWeb3Client).getTransactionReceipt(tx.swap);
+        await File.writeAsync(`./test/fixtures/receipts/swap.json`, receipt);
+    },
+    async 'parse swap logs' () {
+        let swapReceipt = await File.readAsync<TransactionReceipt>('./test/fixtures/receipts/swap.json');
+
+        let parser = new TxLogParser();
+        let logs = await parser.parse(swapReceipt);
+        console.log(logs);
+
+        let dai = logs.find(x => x.token.symbol === 'DAI');
+        eq_(dai.amount, 30000000000000000000000n);
+    }
+})

package/test/utils/abi-parser.spec.ts

@@ -0,0 +1,117 @@
+import { $abiParser } from '../../src/utils/$abiParser'
+
+UTest({
+    'parse empty return' () {
+        let abi = $abiParser.parseMethod('function bar(uint256):()');
+        has_(abi, {
+            type: 'function',
+            name: 'bar',
+            inputs: [
+                {
+                    type: 'uint256',
+                    name: ''
+                }
+            ],
+            outputs: [],
+        });
+    },
+    'parse single return' () {
+        let abi = $abiParser.parseMethod('function foo(uint256) returns address');
+        has_(abi, {
+            outputs: [
+                { type: 'address', name: ''}
+            ],
+        });
+    },
+    'parse multiple return' () {
+        let abi = $abiParser.parseMethod('function foo(uint256) returns (address, uint256)');
+        has_(abi, {
+            outputs: [
+                { type: 'address', name: ''},
+                { type: 'uint256', name: ''},
+            ],
+        });
+    },
+    'parse tuples' () {
+        let abiStr = `function getUserPosition(address) returns [uint256 posid, address token0, address token1, address token][]`;
+        let abi = $abiParser.parseMethod(abiStr);
+        has_(abi, {
+            type: 'function',
+            name: 'getUserPosition',
+            inputs: [
+                {
+                    type: 'address',
+                    name: ''
+                }
+            ],
+            outputs: [
+                {
+                    type: 'tuple[]',
+                    components: [
+                        {
+                            type: 'uint256',
+                            name: 'posid'
+                        },
+                        {
+                            type: 'address',
+                            name: 'token0'
+                        },
+                        {
+                            type: 'address',
+                            name: 'token1'
+                        },
+                        {
+                            type: 'address',
+                            name: 'token'
+                        },
+                    ]
+                }
+            ],
+        });
+    },
+    'parse methods' () {
+
+        [
+            `foo(address):uint256`,
+            `foo ( address ) : uint256`,
+            `foo (address) : (uint256)`,
+            `foo ( address ) returns uint256`,
+            `foo ( address ) returns (uint256)`,
+        ].forEach(str => {
+            let abi = $abiParser.parseMethod(str);
+            eq_(abi.name, 'foo', str);
+            deepEq_(abi.inputs, [ { name: '', type: 'address' } ], str);
+            deepEq_(abi.outputs, [ { name: '', type: 'uint256' } ], str)
+        });
+
+        [
+            `foo(address,uint256):uint256`,
+            `function foo(address, uint256): uint256`,
+        ].forEach(str => {
+            let abi = $abiParser.parseMethod(str);
+            eq_(abi.name, 'foo', str);
+            deepEq_(abi.inputs, [
+                { name: '', type: 'address' },
+                { name: '', type: 'uint256' },
+            ], str);
+            deepEq_(abi.outputs, [ { name: '', type: 'uint256' } ], str)
+        });
+    },
+    'parse with names' () {
+        [
+            `foo(address account, uint256 value):(uint256 foo,uint256 bar)`,
+            `function foo (address account,  uint256 value ) returns (uint256 foo ,uint256 bar)`,
+        ].forEach(str => {
+            let abi = $abiParser.parseMethod(str);
+            eq_(abi.name, 'foo', str);
+            deepEq_(abi.inputs, [
+                { name: 'account', type: 'address' },
+                { name: 'value', type: 'uint256' },
+            ], str);
+            deepEq_(abi.outputs, [
+                { name: 'foo', type: 'uint256' },
+                { name: 'bar', type: 'uint256' },
+            ], str)
+        })
+    }
+})

package/test/utils/bigint.spec.ts

@@ -0,0 +1,40 @@
+import { $bigint } from '@dequanto/utils/$bigint'
+
+
+UTest({
+    'float math': {
+        async 'multiply' () {
+            let val = $bigint.multWithFloat(1000n, .99);
+            eq_(val, 990n);
+
+            val = $bigint.multWithFloat(1000n, 2);
+            eq_(val, 2000n);
+
+            val = $bigint.multWithFloat(1000n, 1/3);
+            eq_(val, 333n);
+
+            val = $bigint.multWithFloat($bigint.toWei(10, 18), 0.025);
+            console.log(val, '<<<');
+        }
+    },
+    'toWei': {
+        async 'fromEther' () {
+            let val = $bigint.toWei(0.011)
+            eq_(val, 11 * 10 ** 15);
+        },
+        async 'fromGwei' () {
+            let val = $bigint.toWeiFromGwei(.5);
+            eq_(val, 5_000_000_00n);
+
+            val = $bigint.toWeiFromGwei(.000001);
+            eq_(val, 1_000n);
+
+            val = $bigint.toWeiFromGwei(1_000_000_000.000001);
+            eq_(val, 1000000000000001000n);
+        },
+        async 'fromCustom' () {
+            let val = $bigint.toWei(0.51, 6)
+            eq_(val, 51_0000);
+        },
+    }
+})

package/test/utils/date.spec.ts

@@ -0,0 +1,8 @@
+import { $date } from '@dequanto/utils/$date'
+
+UTest({
+    'should check add seconds' () {
+        let x = $date.tool().add(`5s`).toUnixTimestamp();
+        console.log(x);
+    }
+})

package/test/utils/fn.spec.ts

@@ -0,0 +1,39 @@
+import { $fn } from '@dequanto/utils/$fn'
+
+function foo (num: number) {
+    if (num < 5) {
+        return Promise.reject(new Error(`Too low: ${num}`));
+    }
+    return Promise.resolve(num);
+}
+
+UTest({
+    async 'should resolve retriable' () {
+        let result = await $fn
+            .retriable(foo, null)
+            .options({
+                async onError (err) {
+                    return [8]
+                }
+            })
+            .call(3);
+
+        eq_(result, 8);
+    },
+    async 'should throw' () {
+        try {
+            await $fn
+                .retriable(foo, null)
+                .options({
+                    async onError (err) {
+                        return [4]
+                    }
+                })
+                .call(3);
+
+            eq_(1, 0);
+        } catch (error) {
+            has_(error.message, `: 4`);
+        }
+    }
+})

package/test/utils/number.spec.ts

@@ -0,0 +1,41 @@
+import { $number } from '@dequanto/utils/$number'
+import alot from 'alot';
+
+UTest({
+    'random': {
+        async 'float with explicit digit-count' () {
+            let min = 0.01;
+            let max = 0.02;
+
+            let values = alot
+                .fromRange(0, 50)
+                .map(() => {
+                    let r = $number.randomFloat(min, max, 8);
+                    gte_(r, min);
+                    lt_(r, max);
+                    return r;
+                })
+                .toArray();
+
+            let distinct = alot(values).distinct().toArray();
+            eq_(distinct.length, values.length, 'No repeated values');
+        },
+        async 'float' () {
+            let min = 0.01;
+            let max = 0.020001;
+
+            let values = alot
+                .fromRange(0, 50)
+                .map(() => {
+                    let r = $number.randomFloat(min, max);
+                    gte_(r, min);
+                    lt_(r, max);
+                    return r;
+                })
+                .toArray();
+
+            let distinct = alot(values).distinct().toArray();
+            eq_(distinct.length, values.length, 'No repeated values');
+        }
+    }
+})

package/test/utils/sign.spec.ts

@@ -0,0 +1,22 @@
+import { ChainAccountProvider } from '@dequanto/ChainAccounts';
+import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client';
+import { $sign } from '@dequanto/utils/$sign';
+
+UTest({
+    async 'eip sign as in web3' () {
+        let acc = ChainAccountProvider.generate({ name: 'test' });
+        let client = new PolyWeb3Client();
+        let web3 = await client.getWeb3();
+
+        let message = 'Hello';
+        let sig1 = web3.eth.accounts.sign(message, acc.key);
+        let sig2 = $sign.signEIPHashed(message, acc.key);
+        eq_(sig1.signature, sig2.signature);
+
+
+        message = `0x1068d820836fa57318e7c3f50d39ef3af08579db1bc9c6371e61549d91de09da`;
+        sig1 = web3.eth.accounts.sign(message, acc.key);
+        sig2 = $sign.signEIPHashed(message, acc.key);
+        eq_(sig1.signature, sig2.signature);
+    }
+})

package/tsconfig-build.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "baseUrl": "./",
+        "paths": {
+            "@dequanto/*": [ "src/*" ],
+            "@dequanto-contracts/*": [ "contracts/*" ]
+        },
+        "outDir": "./dist",
+        "module": "AMD",
+        "moduleResolution": "node",
+        "experimentalDecorators": true,
+        "target": "es2020",
+        "lib": ["dom", "es2018"],
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true
+    },
+    "transformers": {
+        "before": ["ts-nameof"]
+    },
+    "exclude": [
+        "node_modules",
+        "db"
+    ]
+}

package/tsconfig-src.json

@@ -0,0 +1,36 @@
+{
+    "compilerOptions": {
+        "baseUrl": "./",
+        "paths": {
+            "@dequanto/*": [ "src/*" ],
+            "@dequanto-contracts/*": [ "contracts/*" ]
+        },
+        "typeRoots": [
+            "node_modules/@types",
+            "typings/globals"
+        ],
+        "types": ["node", "assertion", "atma-utest"],
+
+        "outDir": "dist",
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "experimentalDecorators": true,
+        "target": "es2020",
+        "lib": ["dom", "es2018"],
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true
+    },
+    "transformers": {
+        "before": ["ts-nameof"]
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "db",
+        "test",
+        "**/*.spec.ts",
+        "src/gen/ContractTemplate.ts"
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "baseUrl": "./",
+        "paths": {
+            "@dequanto/*": [ "src/*" ],
+            "@dequanto-contracts/*": [ "contracts/*" ]
+        },
+        "typeRoots": [
+            "node_modules/@types",
+            "typings",
+            "typings/globals"
+        ],
+        "types": ["node", "assertion", "atma-utest"],
+        "declaration": true,
+
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "experimentalDecorators": true,
+        "target": "es2020",
+        "lib": ["dom", "es2018"],
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true
+    },
+    "transformers": {
+        "before": ["ts-nameof"]
+    }
+}

package/typings/globals/assertion/index.d.ts

@@ -0,0 +1,159 @@
+// Generated by typings
+// Source: https://raw.githubusercontent.com/atmajs/assertion/master/types/assertion.d.ts
+declare module "assertion" {
+	export = assert;
+}
+
+declare var assert: assertion.IAssert
+
+declare var eq_: assertion.equal
+declare var notEq_: assertion.notEqual
+declare var lt_: assertion.lessThan
+declare var lte_: assertion.lessThanOrEqual
+declare var gt_: assertion.greaterThan
+declare var gte_: assertion.greaterThanOrEqual
+declare var deepEq_: assertion.deepEqual
+declare var notDeepEq_: assertion.notDeepEqual
+declare var has_: assertion.has
+declare var hasNot_: assertion.hasNot
+declare var is_: assertion.is
+declare var isNot_: assertion.isNot
+
+
+declare namespace assertion {
+	interface IAssert {
+		(expression: boolean, message: string): void
+		equal: equal
+		notEqual: notEqual
+		strictEqual: strictEqual
+		notStrictEqual: notStrictEqual
+		throws: throws
+		notThrows: notThrows
+		ifError: ifError
+		lessThan: lessThan
+		lessThanOrEqual: lessThanOrEqual
+		
+		greaterThan: greaterThan
+		greaterThanOrEqual: greaterThanOrEqual
+		deepEqual: deepEqual
+		notDeepEqual: notDeepEqual
+		has: has
+        hasNot: hasNot        
+        is: is
+
+        on: on
+        
+        /**
+         *  string: Await Name for better logging
+         *  number: expectation count
+         *  object: binded content
+         *  function: wrap any function
+         */
+        await (
+            arg1?: string | number | Function | object,   
+            arg2?: string | number | Function | object,   
+            arg3?: string | number | Function | object,   
+            arg4?: string | number | Function | object,   
+        ): Function
+        
+        
+        /**
+         *  string: Await Name for better logging
+         *  number: expectation count, default is `1`
+         *  object: binded content
+         *  function: wrap any function
+         */
+        avoid (
+			arg1?: string | number | Function | object,   
+            arg2?: string | number | Function | object,   
+            arg3?: string | number | Function | object,   
+            arg4?: string | number | Function | object,   
+		);
+	}
+	interface equal {
+		(a: any, b: any, message?: string)
+	}
+	interface notEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface strictEqual {
+		(a: any, b: any, message?: string)		
+	}
+	interface notStrictEqual {
+		(a: any, b: any, message?: string)			
+	}
+	interface throws {
+		(a: Function, message?: string): Error	
+	}
+	interface notThrows {
+		(a: Function, message?: string): Error	
+	}
+	interface ifError {
+		(a: any, message?: string)			
+	}	
+	interface lessThan {
+		(a: any, b: any, message?: string)
+	}
+	interface lessThanOrEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface greaterThan {
+		(a: any, b: any, message?: string)
+	}
+	interface greaterThanOrEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface deepEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface notDeepEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface has {
+		(a: any, b: any, message?: string)
+    }
+    interface is {
+        (a: any, b: 
+            'String' |
+            'Number' |
+            'Null' |
+            'Undefined' |
+            'Function' |
+            'RegExp' |
+            'Date' |
+            'Object' |
+            'CustomEvent' |
+            null | 
+            any, message?: string)
+    }
+    interface isNot {
+		(a: any, b: 
+            'String' |
+            'Number' |
+            'Null' |
+            'Undefined' |
+            'Function' |
+            'RegExp' |
+            'Date' |
+            'Object' |
+            'CustomEvent' |
+            null | 
+            any, message?: string)
+	}
+	interface hasNot {
+		(a: any, b: any, message?: string)
+	}
+
+
+	/** Notice: when `fail` callback is defined the assertion doesn`t throw any error */
+	interface on {
+		(event: 'start' | 'fail' | 'success', callback: (error?: AssertionError) => void)
+	}
+	
+
+	interface AssertionError extends Error {
+		actual: any
+		expected: any
+		operator: string
+	}
+}

package/typings/globals/assertion/typings.json

@@ -0,0 +1,10 @@
+{
+  "resolution": "main",
+  "tree": {
+    "src": "https://raw.githubusercontent.com/atmajs/assertion/master/typings.json",
+    "raw": "github:atmajs/assertion",
+    "main": "types/assertion.d.ts",
+    "global": true,
+    "name": "assertion"
+  }
+}