dequanto 0.0.1 → 0.0.7

package/test/solidity/Storage.spec.ts

@@ -0,0 +1,328 @@
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { SlotsParser } from '@dequanto/solidity/SlotsParser';
+import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
+import { $address } from '@dequanto/utils/$address';
+import { l } from '@dequanto/utils/$logger';
+
+UTest({
+    async 'should read and write simple Value Types'() {
+        let code = `
+            contract Foo {
+                uint256 public iNumber = 41;
+                bool public iBool = true;
+                string public iString = "hello";
+                address public iAddress = 0x0000000000000000000000000000000000000000;
+                bytes2 public iBytes = 0xFFEE;
+
+                enum FooEnum { foo, bar, qux }
+
+                FooEnum public iEnum = FooEnum.bar;
+            }
+        `;
+
+        let provider = new HardhatProvider();
+        let client = await provider.client();
+
+        let { contract } = await provider.deployCode(code, { client });
+        let slots = await SlotsParser.slots({ path: '', code });
+        let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+        return UTest({
+            async 'NUMBER' () {
+                let iNumber = await storage.get('iNumber');
+                eq_(iNumber, 41n);
+
+                await storage.set('iNumber', '0x7');
+                iNumber = await storage.get('iNumber');
+                eq_(iNumber, 7n);
+            },
+            async 'BOOLEAN' () {
+                let iBool = await storage.get('iBool');
+                eq_(iBool, true);
+
+                await storage.set('iBool', false);
+                iBool = await storage.get('iBool');
+                eq_(iBool, false);
+            },
+            async 'STRING' () {
+                let iString = await storage.get('iString');
+                eq_(iString, "hello");
+
+                await storage.set('iString', "world");
+                iString = await storage.get('iString');
+                eq_(iString, "world");
+            },
+            async 'ADDRESS' () {
+                let iAddress = await storage.get('iAddress');
+                eq_(iAddress, $address.ZERO);
+
+                let newAddress = $address.ZERO.replace('x0', 'x1');
+
+                await storage.set('iAddress', newAddress);
+                iAddress = await storage.get('iAddress');
+                eq_(iAddress, newAddress);
+            },
+            async 'BYTES' () {
+                let iBytes = await storage.get('iBytes');
+                eq_(iBytes, '0xffee');
+
+
+                await storage.set('iBytes', '0xeeff');
+                iBytes = await storage.get('iBytes');
+                eq_(iBytes, '0xeeff');
+            },
+            async 'ENUM' () {
+                let value = await storage.get('iEnum');
+                eq_(value, 1);
+
+                await storage.set('iEnum', 2);
+                value = await storage.get('iEnum');
+                eq_(value, 2);
+            }
+        })
+    },
+
+    async 'should read and write fix-sized structs'() {
+        let code = `
+            contract Foo {
+                struct User {
+                    uint256 ID;
+                    uint256 balance;
+                }
+                struct UserContainer {
+                    User user;
+                }
+
+                User public user = User(3, 4);
+                UserContainer public container = UserContainer(User(5, 6));
+            }
+        `;
+
+        let provider = new HardhatProvider();
+        let client = await provider.client();
+
+        let { contract } = await provider.deployCode(code, { client });
+        let slots = await SlotsParser.slots({ path: '', code });
+        let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+        return UTest({
+            async 'read single in simple structure' () {
+                let user = await storage.get('user');
+                deepEq_(user, {
+                    ID: 3n,
+                    balance: 4n,
+                })
+
+                let value = await storage.get('user.ID');
+                eq_(value, 3n);
+
+                await storage.set('user.ID', 7n);
+                value = await storage.get('user.ID');
+                eq_(value, 7n);
+            },
+
+
+            async 'nested structure' () {
+                let container = await storage.get('container');
+                deepEq_(container, {
+                    user: {
+                        ID: 5n,
+                        balance: 6n,
+                    }
+                });
+
+                let user = await storage.get('container.user');
+                deepEq_(user, {
+                    ID: 5n,
+                    balance: 6n,
+                });
+
+                let value = await storage.get('container.user.ID');
+                deepEq_(value, 5n);
+
+                await storage.set('container.user.ID', 3n);
+                value = await storage.get('container.user.ID');
+                eq_(value, 3n);
+            },
+        })
+    },
+
+    async 'should read and write arrays'() {
+        let code = `
+            contract Foo {
+                struct User {
+                    uint256 ID;
+                    uint256 balance;
+                }
+                uint256[3] fixSized = [ 2, 3, 4 ];
+                User[1] fixSizedStructs;
+
+                uint256[] dynamicSized = [ 5, 6, 7 ];
+
+                User[] dynamicSizedStructs;
+
+                constructor () {
+                    fixSizedStructs[0] = User(11, 12);
+                    dynamicSizedStructs.push(User(18, 19));
+                    dynamicSizedStructs.push(User(20, 21));
+                }
+            }
+        `;
+
+        let provider = new HardhatProvider();
+        let client = await provider.client();
+
+        let { contract } = await provider.deployCode(code, { client });
+        let slots = await SlotsParser.slots({ path: '', code });
+        let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+        return UTest({
+            async 'read and write fixed sized array' () {
+                let v0 = await storage.get('fixSized[0]');
+                eq_(v0, 2n);
+
+                let v1 = await storage.get('fixSized[1]');
+                eq_(v1, 3n);
+
+                await storage.set('fixSized[1]', 8n);
+                v1 = await storage.get('fixSized[1]');
+                eq_(v1, 8n);
+
+                let readAll = await storage.get('fixSized');
+                deepEq_(readAll, [ 2n, 8n, 4n ]);
+            },
+            async 'read and write fixed sized array with Structs' () {
+                let v0 = await storage.get('fixSizedStructs[0].ID');
+                eq_(v0, 11n);
+
+                let v1 = await storage.get('fixSizedStructs[0].balance');
+                eq_(v1, 12n);
+
+                let vAll = await storage.get('fixSizedStructs[0]');
+                deepEq_(vAll, { ID: 11n, balance: 12n });
+
+                await storage.set('fixSizedStructs[0].balance', 17n);
+                v1 = await storage.get('fixSizedStructs[0].balance');
+                eq_(v1, 17n);
+            },
+            async 'read and write dynamic sized array' () {
+                let v0 = await storage.get('dynamicSized[0]');
+                eq_(v0, 5n);
+
+                let v1 = await storage.get('dynamicSized[1]');
+                eq_(v1, 6n);
+
+                let v2 = await storage.get('dynamicSized[2]');
+                eq_(v2, 7n);
+
+                await storage.set('dynamicSized[1]', 15n);
+                v1 = await storage.get('dynamicSized[1]');
+                eq_(v1, 15n);
+            },
+            async 'read and write dynamic sized array with Structs' () {
+                let v0_0 = await storage.get('dynamicSizedStructs[0].ID');
+                eq_(v0_0, 18n);
+
+                let v0_1 = await storage.get('dynamicSizedStructs[0].balance');
+                eq_(v0_1, 19n);
+
+                let v1_0 = await storage.get('dynamicSizedStructs[1].ID');
+                eq_(v1_0, 20n);
+
+                let v1_1 = await storage.get('dynamicSizedStructs[1].balance');
+                eq_(v1_1, 21n);
+
+                await storage.set('dynamicSizedStructs[1].ID', 55n);
+                v1_0 = await storage.get('dynamicSizedStructs[1].ID');
+                eq_(v1_0, 55n);
+            },
+        })
+    },
+
+    async 'should read and write mappings'() {
+        let code = `
+            contract Foo {
+                struct User {
+                    uint256 ID;
+                    uint256 balance;
+                }
+                mapping(uint256 => uint256) ids;
+                mapping(address => uint256) addresses;
+                mapping(address => User) users;
+
+
+                constructor () {
+                    ids[1] = 2;
+                    ids[7] = 8;
+
+                    addresses[address(0xC000000000000000000000000000000000000000)] = 3;
+
+                    users[address(0xa000000000000000000000000000000000000000)] = User(10,11);
+                    users[address(0xB000000000000000000000000000000000000000)] = User(12,13);
+                }
+            }
+        `;
+
+        let provider = new HardhatProvider();
+        let client = await provider.client();
+
+        let { contract } = await provider.deployCode(code, { client });
+        let slots = await SlotsParser.slots({ path: '', code });
+        let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+        return UTest({
+            async 'read and write (number---number) mapping' () {
+                let v0 = await storage.get('ids["1"]');
+                eq_(v0, 2n);
+
+                let v1 = await storage.get('ids["7"]');
+                let v1_ = await storage.get('ids[7]');
+
+                eq_(v1, 8n);
+                eq_(v1_, 8n);
+
+                await storage.set('ids[7]', 9n);
+                v1 = await storage.get(['ids', 7]);
+                eq_(v1, 9n);
+            },
+            async 'read and write (address---number) mapping' () {
+                let v0 = await storage.get('addresses["0xC000000000000000000000000000000000000000"]');
+                eq_(v0, 3n);
+
+                await storage.set('addresses["0xC000000000000000000000000000000000000000"]', 21n);
+                v0 = await storage.get('addresses["0xC000000000000000000000000000000000000000"]');
+                eq_(v0, 21n);
+            },
+            async 'read and write (address---struct) mapping' () {
+                let v0 = await storage.get('users["0xa000000000000000000000000000000000000000"].ID');
+                eq_(v0, 10n);
+
+                let v1 = await storage.get('users["0xa000000000000000000000000000000000000000"].balance');
+                eq_(v1, 11n);
+
+                deepEq_([
+                    await storage.get('users["0xB000000000000000000000000000000000000000"].ID'),
+                    await storage.get('users["0xB000000000000000000000000000000000000000"].balance'),
+                ], [ 12n, 13n ]);
+
+
+                await storage.set('users["0xa000000000000000000000000000000000000000"].balance', 500n);
+
+                v1 = await storage.get('users["0xa000000000000000000000000000000000000000"].balance');
+                eq_(v1, 500n);
+
+                await storage.set('users["0xa000000000000000000000000000000000000000"]', {
+                    ID: 30n,
+                    balance: 1000n
+                });
+
+                let arr = [
+                    await storage.get('users["0xa000000000000000000000000000000000000000"].ID'),
+                    await storage.get(['users', '0xa000000000000000000000000000000000000000', 'balance']),
+                ];
+                deepEq_(arr, [ 30n, 1000n ]);
+            },
+        })
+    },
+
+})

package/test/structs/PackedRanges.spec.ts

@@ -0,0 +1,56 @@
+import { PackedRanges } from '@dequanto/structs/PackedRanges';
+
+UTest({
+    'adding numbers' () {
+        let tracker = new PackedRanges({
+            ranges: [[1,100]]
+        });
+
+        tracker.add(101);
+        deepEq_(tracker['ranges'], [[1, 101]])
+
+        tracker['ranges'] = [[5,100]];
+        tracker.add(4);
+        deepEq_(tracker['ranges'], [[4, 100]])
+
+        tracker['ranges'] = [[1,100]];
+        tracker.add(102);
+        deepEq_(tracker['ranges'], [[1, 100], [102,102]]);
+
+        tracker.add(103);
+        deepEq_(tracker['ranges'], [[1, 100], [102,103]]);
+
+        tracker.add(101);
+        deepEq_(tracker['ranges'], [[1, 101], [102,103]]);
+
+        tracker.add(102);
+        deepEq_(tracker['ranges'], [[1, 102], [102,103]]);
+
+        tracker.compact();
+        deepEq_(tracker['ranges'], [[1, 103]]);
+
+        eq_(tracker.includes(50), true);
+        eq_(tracker.includes(120), false);
+
+        tracker.remove(89);
+        deepEq_(tracker['ranges'], [[1, 88], [90,103]]);
+
+
+        tracker = new PackedRanges({
+            from: 5, to: 10,
+        });
+        eq_(tracker.includes(5), false);
+        eq_(tracker.next(), 5);
+        eq_(tracker.includes(5), true);
+        eq_(tracker.next(), 6);
+        eq_(tracker.next(), 7);
+
+        '> adding manual';
+        tracker.add(8);
+
+        eq_(tracker.next(), 9);
+        eq_(tracker.next(), null);
+
+        deepEq_(tracker['ranges'], [ [5, 9] ]);
+    }
+})

package/test/subscriptions.spec.ts

@@ -0,0 +1,127 @@
+import { Generator } from '@dequanto/gen/Generator';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { l } from '@dequanto/utils/$logger';
+import { $promise } from '@dequanto/utils/$promise';
+import { ConstructorFragment } from 'ethers/lib/utils';
+import { TestNode } from './hardhat/TestNode';
+
+import sinon = require('sinon');
+
+declare let include;
+
+UTest({
+    async $before () {
+        await TestNode.start();
+
+    },
+    async 'subscribe to methods and events' () {
+        let provider = new HardhatProvider();
+        let client = provider.client('localhost');
+        let acc1 = provider.deployer();
+
+        let { contract, abi } = await provider.deploySol('/test/fixtures/contracts/Foo.sol', {
+            arguments: [ 'Lorem' ],
+            client
+        });
+
+        const gen = new Generator({
+            name: 'Foo',
+            platform: 'hardhat',
+            source: {
+                abi: './artifacts/test/fixtures/contracts/Foo.sol/Foo.json'
+            },
+            output: './test/tmp/eth/'
+        });
+        await gen.generate();
+
+        let { Foo } = await include.js('/test/tmp/eth/Foo/Foo.ts');
+
+        let foo = new Foo.Foo (contract.address, client);
+
+        l`Listen to ALL transactions`
+        let onTransactionAllSpy = sinon.spy();
+        foo.onTransaction('*').subscribe(onTransactionAllSpy);
+
+        l`Listen to specific transaction`
+        let onTransactionMethodSpy = sinon.spy();
+        foo.onTransaction('setName').subscribe(onTransactionMethodSpy);
+
+        l`Listen to ALL events`
+        let onLogAllSpy = sinon.spy();
+        foo.onLog('*').subscribe(onLogAllSpy);
+
+        l`Listen to specific event`
+        let onLogEventSpy = sinon.spy();
+        foo.onLog('Updated').subscribe(onLogEventSpy);
+
+        let onLogEvent2Spy = sinon.spy();
+        foo.onLog('Updated2').subscribe(onLogEvent2Spy);
+
+        l`Listen to specific event via Method`
+        let onLogMethodSpy = sinon.spy();
+        foo.onUpdated(onLogMethodSpy);
+
+        let writer = await foo.setName(acc1.address, 'Ipsum');
+        let receipt = await writer.wait();
+        eq_(receipt.transactionHash, writer.tx.hash);
+
+
+
+        await $promise.waitForTrue(() => onTransactionAllSpy.callCount > 0);
+        await $promise.waitForTrue(() => onLogAllSpy.callCount > 0);
+        await $promise.waitForTrue(() => onLogEventSpy.callCount > 0);
+
+        eq_(onTransactionAllSpy.callCount, 1);
+        eq_(onTransactionMethodSpy.callCount, 1);
+
+        l`Check ALL events called`
+        eq_(onLogAllSpy.callCount, 1);
+        has_(onLogAllSpy.args[0][0], {
+            name: 'Updated',
+            arguments: [ { name: 'newName', value: 'Ipsum' } ]
+        });
+
+        l`Check specific event called`
+        eq_(onLogEvent2Spy.callCount, 0);
+        eq_(onLogEventSpy.callCount, 1);
+        has_(onLogEventSpy.args[0][0], {
+            name: 'Updated',
+            arguments: [ { name: 'newName', value: 'Ipsum' } ]
+        });
+
+        l`Check specific method event called`
+        eq_(onLogMethodSpy.callCount, 1);
+        has_(onLogMethodSpy.args[0][0], {
+            name: 'Updated',
+            arguments: [ { name: 'newName', value: 'Ipsum' } ]
+        });
+
+
+        l`Should send another tx`
+        let writer2 = await foo.setName2(acc1, 'Boo');
+        let receipt2 = await writer2.wait();
+        eq_(receipt2.transactionHash, writer2.tx.hash);
+
+        await $promise.waitForTrue(() => onTransactionAllSpy.callCount > 1);
+        eq_(onTransactionAllSpy.callCount, 2);
+        eq_(onTransactionMethodSpy.callCount, 1);
+
+        l`Check ALL events called`
+        eq_(onLogAllSpy.callCount, 2);
+
+        l`Check specific event called`
+        eq_(onLogEventSpy.callCount, 1);
+
+        l`Check specific method event called`
+        l`"Update" should stay 1`
+        eq_(onLogMethodSpy.callCount, 1);
+
+        l`"Update2" should be received`
+        eq_(onLogEvent2Spy.callCount, 1);
+        has_(onLogEvent2Spy.args[0][0], {
+            name: 'Updated2',
+            arguments: [ { name: 'newName', value: 'Boo' } ]
+        });
+    }
+})

package/test/token.spec.ts

@@ -0,0 +1,11 @@
+import { TokensService } from '@dequanto/tokens/TokensService';
+
+UTest({
+    async 'should load token data' () {
+        let service = new TokensService('eth');
+        let usdc = await service.getKnownToken('USDC');
+        eq_(usdc.decimals, 6);
+        eq_(usdc.name, 'USD Coin');
+        eq_(usdc.address, '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48');
+    }
+})

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

@@ -0,0 +1,31 @@
+import { $abiType } from '@dequanto/utils/$abiType'
+import { $abiUtils } from '@dequanto/utils/$abiUtils'
+
+UTest({
+    'get event topic hash'() {
+        ([
+            [`uint256`, `bigint`],
+            [`mapping(address => uint8)`, `Record<TAddress, number>`],
+            [`bool[]`, `boolean[]`],
+            ['(string foo, bool bar)', '{ foo: string, bar: boolean }'],
+            [ '(((uint256[] _values) _inner) members)', '{ members: { _inner: { _values: bigint[] } } }' ],
+
+            [ 'mapping(bytes32 => uint8[])', 'Record<TBufferLike, number[]>' ],
+            [ 'mapping(bytes32 => (uint8[] foo))', 'Record<TBufferLike, { foo: number[] }>' ],
+            [
+                '(((bytes32[] _values, mapping(bytes32 => uint256) _indexes) _inner) members, bytes32 adminRole)',
+                '{ members: { _inner: { _values: TBufferLike[], _indexes: Record<TBufferLike, bigint> } }, adminRole: TBufferLike }'
+            ],
+            [
+                'mapping(bytes32 => (((bytes32[] _values, mapping(bytes32 => uint256) _indexes) _inner) members, bytes32 adminRole))',
+                'Record<TBufferLike, { members: { _inner: { _values: TBufferLike[], _indexes: Record<TBufferLike, bigint> } }, adminRole: TBufferLike }>'
+            ]
+        ]).forEach(([ sol, ts ]) => {
+
+            let result = $abiType.getTsTypeFromDefinition(sol);
+
+            result = result.replace(/\n/g, ', ');
+            eq_(result, ts);
+        })
+    }
+})

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

@@ -0,0 +1,23 @@
+import { $abiUtils } from '@dequanto/utils/$abiUtils'
+
+UTest({
+    'get event topic hash'() {
+        let hash = $abiUtils.getTopicSignature({
+            anonymous: false,
+            inputs: [
+                { indexed: true, internalType: "address", name: "from", type: "address" },
+                { indexed: true, internalType: "address", name: "to", type: "address" },
+                {
+                    indexed: false,
+                    internalType: "uint256",
+                    name: "value",
+                    type: "uint256",
+                },
+            ],
+            name: "Transfer",
+            type: "event",
+        });
+
+        eq_(hash, '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef');
+    }
+})

package/test/utils/bigint.spec.ts

@@ -14,7 +14,6 @@ UTest({
             eq_(val, 333n);
 
             val = $bigint.multWithFloat($bigint.toWei(10, 18), 0.025);
-            console.log(val, '<<<');
         }
     },
     'toWei': {

package/test/utils/date.spec.ts

@@ -2,7 +2,8 @@ import { $date } from '@dequanto/utils/$date'
 
 UTest({
     'should check add seconds' () {
-        let x = $date.tool().add(`5s`).toUnixTimestamp();
-        console.log(x);
+        let date = new Date();
+        let x = $date.tool(date).add(`5s`).toUnixTimestamp();
+        eq_(x, (date.valueOf() / 1000 | 0) + 5);
     }
 })

package/test/utils/logbloom.spec.ts

@@ -0,0 +1,17 @@
+import { $bloom } from '@dequanto/utils/$bloom';
+import { $contract } from '@dequanto/utils/$contract';
+import { $hex } from '@dequanto/utils/$hex';
+
+UTest({
+    async 'check the topic' () {
+        // nr. 15001871 tx 0x311ba3a0affb00510ae3f0a36c5bcd0a48cdb23d803bbc16f128639ffb9e3e58
+        let logsBloom = '0x0100000000000004000000000000100000000000000000000000000000200000000000000000000000000000000001000000000000000000080008000000000040000000002000000000040800000000000000000000200000000000004800000040000002000000000000000000081000000000000040000000001080020000200001000000000000000000040000004000000000000000000000000010000000008000000000000800008000000800000000008000000200000800000000000000200a000000200000000000100002004000000000000000000000000020000000000080000020000000800000000000004000000000000000080000004000';
+        // Transfer(address,address,uint256)
+        let topic = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+
+        let has = $bloom.check(logsBloom, topic)
+        eq_(has, true);
+
+    }
+})
+

package/test/utils/number.spec.ts

@@ -18,14 +18,14 @@ UTest({
                 .toArray();
 
             let distinct = alot(values).distinct().toArray();
-            eq_(distinct.length, values.length, 'No repeated values');
+            eq_(distinct.length, values.length, 'Has repeated values.');
         },
         async 'float' () {
             let min = 0.01;
             let max = 0.020001;
 
             let values = alot
-                .fromRange(0, 50)
+                .fromRange(0, 20)
                 .map(() => {
                     let r = $number.randomFloat(min, max);
                     gte_(r, min);
@@ -35,7 +35,18 @@ UTest({
                 .toArray();
 
             let distinct = alot(values).distinct().toArray();
-            eq_(distinct.length, values.length, 'No repeated values');
+            eq_(distinct.length, values.length, 'Has repeated values. Random?');
         }
+    },
+    'should parse number' () {
+        [
+            [ '5.3', 5.3 ],
+            [ '5.3K', 5300 ],
+            [ '5.321M', 5321000 ],
+            [ '5.321B', 5321000000 ],
+
+        ].forEach(([val, expect]) => {
+            eq_($number.parse(val), expect);
+        });
     }
 })