dequanto 0.0.1 → 0.0.7

package/test/fixtures/slots/FooStorage.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+import './FooStorageBase.sol';
+
+contract FooStorage is FooStorageBase {
+    uint256 foo = 2;
+}

package/test/fixtures/slots/FooStorageBase.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+contract FooStorageBase {
+    uint256 fooBase = 1;
+}

package/test/fixtures/slots/Vault.sol

@@ -0,0 +1,85 @@
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+/*
+Note: cannot use web3 on JVM, so use the contract deployed on Goerli
+Note: browser Web3 is old so use Web3 from truffle console
+
+Contract deployed on Goerli
+0x534E4Ce0ffF779513793cfd70308AF195827BD31
+*/
+
+/*
+# Storage
+- 2 ** 256 slots
+- 32 bytes for each slot
+- data is stored sequentially in the order of declaration
+- storage is optimized to save space. If neighboring variables fit in a single
+  32 bytes, then they are packed into the same slot, starting from the right
+*/
+
+contract Vault {
+    // slot 0
+    uint public count = 123;
+    // slot 1
+    address public owner = msg.sender;
+    bool public isTrue = true;
+    uint16 public u16 = 31;
+    // slot 2
+    bytes32 private password;
+
+    // constants do not use storage
+    uint public constant someConst = 123;
+
+    // slot 3, 4, 5 (one for each array element)
+    bytes32[3] public data;
+
+    struct User {
+        uint id;
+        bytes32 password;
+    }
+
+    // slot 6 - length of array
+    // starting from slot hash(6) - array elements
+    // slot where array element is stored = keccak256(slot)) + (index * elementSize)
+    // where slot = 6 and elementSize = 2 (1 (uint) +  1 (bytes32))
+    User[] private users;
+
+    // slot 7 - empty
+    // entries are stored at hash(key, slot)
+    // where slot = 7, key = map key
+    mapping(uint => User) private idToUser;
+
+    // slot 8
+    string private dynamicSlotString = "0123456789012345678901234567890123456789012345678901234567890";
+    string private singleSlotString = "hello";
+
+    constructor(bytes32 _password) {
+        password = _password;
+        data[0] = "one";
+        data[1] = "two";
+        data[2] = "three";
+        addUser(data[0]);
+        addUser(data[1]);
+    }
+
+    function addUser(bytes32 _password) public {
+        User memory user = User({id: users.length, password: _password});
+
+        users.push(user);
+        idToUser[user.id] = user;
+    }
+
+    function getArrayLocation(
+        uint slot,
+        uint index,
+        uint elementSize
+    ) public pure returns (uint) {
+        return uint(keccak256(abi.encodePacked(slot))) + (index * elementSize);
+    }
+
+    function getMapLocation(uint slot, uint key) public pure returns (uint) {
+        return uint(keccak256(abi.encodePacked(key, slot)));
+    }
+}

package/test/generate/class.spec.ts

@@ -1,10 +1,73 @@
+import hh from 'hardhat';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
 import { Generator } from '@dequanto/gen/Generator';
 import { $path } from '@dequanto/utils/$path';
-import { File } from 'atma-io';
+import { Directory, File } from 'atma-io';
+import { $date } from '@dequanto/utils/$date';
+import { l } from '@dequanto/utils/$logger';
+import { ContractReader } from '@dequanto/contracts/ContractReader';
+import { TestNode } from '../hardhat/TestNode';
+import { $promise } from '@dequanto/utils/$promise';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { $contract } from '@dequanto/utils/$contract';
+import { $txData } from '@dequanto/utils/$txData';
+import { Wallet } from 'ethers';
+import { $fn } from '@dequanto/utils/$fn';
+
+declare let include;
 
 UTest({
-    async 'generate test' () {
-        let genPath = `/test/tmp/polygon/DaiTokenContractBase.ts`
+    $config: {
+        timeout: $date.parseTimespan('5min'),
+    },
+
+    async $before () {
+        await TestNode.start();
+    },
+
+    async 'generate polygons WETH' () {
+
+        const gen = new Generator({
+            name: 'WETH',
+            platform: 'polygon',
+            source: {
+                abi: '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619'
+            },
+            output: './test/tmp/polygon/'
+        });
+        await gen.generate();
+
+        let { WETH } = await include.js('/test/tmp/polygon/WETH/WETH.ts');
+
+
+        let weth = new WETH.WETH();
+        let decimals = await weth.decimals();
+        eq_(decimals, 18);
+
+        '> read in batch'
+
+        let nameReq = weth
+            .$config({ send: 'manual' })
+            .name();
+
+        let totalSupplyReq = await weth
+            .$config({ send: 'manual' })
+            .totalSupply();
+
+        let reader = new ContractReader(weth.client);
+        let [ name, totalSupply ] = await reader.executeBatch([ nameReq, totalSupplyReq ]);
+
+        eq_(name, 'Wrapped Ether');
+        gt_(totalSupply, 1000n);
+
+        let nameFromSlot = await weth.storage._name();
+        eq_(nameFromSlot, name);
+
+    },
+    async 'generate from class meta comments and check the sources' () {
+        let genPath = `/test/tmp/polygon/DaiTokenContractBase/DaiTokenContractBase.ts`
 
         try {
             await File.removeAsync(genPath);
@@ -15,13 +78,88 @@ UTest({
 
         let templatePath = $path.resolve(`/src/gen/ContractTemplate.ts`);
         let exists = await File.exists(templatePath);
-        eq_(exists, true);
+        eq_(exists, true, `Path 404: ${templatePath}`);
         await Generator.generateForClass('/test/fixtures/DaiTokenContract.ts');
 
         existsBase = await File.exists(genPath);
-        eq_(existsBase, true);
+        eq_(existsBase, true, `Path 404: ${genPath}`);
 
         let source = await File.readAsync(genPath, { skipHooks: true });
         has_(source, 'onTransfer');
-    }
+    },
+    async 'generate and check with deployed contract' () {
+
+        let provider = new HardhatProvider();
+        let client = await provider.client('localhost');
+
+
+        await hh.run('compile', {
+            sources: '/test/fixtures/contracts',
+            tsgen: false
+        });
+        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:any = await provider.deployClass(Foo.Foo, {
+            arguments: [ 'hello' ],
+            client
+        });
+
+        let name = await foo.name();
+        eq_(name, 'hello');
+
+        await $promise.wait(2000);
+
+        l`Subscribe to transactions stream`
+        const transactionsListener = [];
+        foo.onTransaction('*').subscribe((data) => {
+            transactionsListener.push(data.calldata);
+        });
+
+        l`Set new name`
+        let tx = await foo.setName(provider.deployer(), 'bar');
+        let receipt = await tx.wait();
+        eq_(receipt.status, true);
+
+
+        l`Check name was set`
+        name = await foo.name();
+        eq_(name, 'bar');
+
+        l`Check logs`
+        let logs = await foo.getPastLogsUpdated({});
+        gte_(logs.length, 1);
+
+        let log = logs[logs.length - 1];
+        eq_(log.transactionHash, tx.tx.hash);
+        eq_(log.event, 'Updated');
+        eq_(log.params.newName, 'bar');
+
+        l`Check overloads`
+        let zero = await foo.someEcho();
+        eq_(zero, 0);
+
+        let echoed = await foo.someEcho(2);
+        eq_(echoed, 2);
+
+
+        await $promise.waitForTrue(() => transactionsListener.length > 0, {
+            timeoutMessage: `Transactions were not captured`,
+            timeoutMs: 4000,
+            intervalMs: 100,
+        });
+
+        let methods = transactionsListener.map(x => x.method);
+        deepEq_(methods, ['setName']);
+
+    },
 })

package/test/generate/evm.spec.ts

@@ -0,0 +1,64 @@
+import { EVM } from '@dequanto/evm/evm';
+import alot from 'alot';
+
+UTest({
+    async 'parse the bytecode of a proxy contract' () {
+        let bytecode = '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';
+        let evm = new EVM(bytecode);
+        let abi = await evm.getAbi();
+
+        let upgradeTo = abi.find(x => x.name === 'upgradeTo');
+        has_(upgradeTo, {
+            name: 'upgradeTo',
+            inputs: [ { name: '', type: 'address' } ],
+            outputs: [],
+            type: 'function'
+        });
+
+        let implementation = abi.find(x => x.name === 'implementation');
+        has_(implementation, {
+            name: 'implementation',
+            inputs: [],
+            outputs: [],
+            type: 'function',
+            stateMutability: 'view',
+        });
+
+        let upgraded = abi.find(x => x.name === 'Upgraded');
+        has_(upgraded, {
+            name: 'Upgraded',
+            inputs: [ { name: '', type: 'address' } ],
+            outputs: [],
+            type: 'event'
+        });
+    },
+    async 'parse Counter.sol bytecode (raw and optimized)' () {
+        // fixtures/contracts/Counter.sol
+        // playground https://www.evm.codes/playground?fork=merge
+        let bytecodeRaw = '0x608060405234801561001057600080fd5b50610298806100206000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c806306661abd1461005c578063371303c01461007a57806360fe47b1146100845780636d4ce63c146100a0578063b3bcfa82146100be575b600080fd5b6100646100c8565b6040516100719190610168565b60405180910390f35b6100826100ce565b005b61009e6004803603810190610099919061012c565b6100e9565b005b6100a86100f3565b6040516100b59190610168565b60405180910390f35b6100c66100fc565b005b60005481565b60016000808282546100e09190610183565b92505081905550565b8060008190555050565b60008054905090565b600160008082825461010e91906101d9565b92505081905550565b6000813590506101268161024b565b92915050565b60006020828403121561014257610141610246565b5b600061015084828501610117565b91505092915050565b6101628161020d565b82525050565b600060208201905061017d6000830184610159565b92915050565b600061018e8261020d565b91506101998361020d565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156101ce576101cd610217565b5b828201905092915050565b60006101e48261020d565b91506101ef8361020d565b92508282101561020257610201610217565b5b828203905092915050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600080fd5b6102548161020d565b811461025f57600080fd5b5056fea264697066735822122062cca91a84d90195cd174bf9ce7cf864efc93252479096b852535063f7e92b4964736f6c63430008070033';
+        let bytecodeOptimized = '0x608060405234801561001057600080fd5b50610116806100206000396000f3fe6080604052348015600f57600080fd5b506004361060465760003560e01c806306661abd14604b578063371303c01460655780636d4ce63c14606d578063b3bcfa82146074575b600080fd5b605360005481565b60405190815260200160405180910390f35b606b607a565b005b6000546053565b606b6091565b6001600080828254608a919060a1565b9091555050565b6001600080828254608a919060b6565b6000821982111560b15760b160ca565b500190565b60008282101560c55760c560ca565b500390565b634e487b7160e01b600052601160045260246000fdfea2646970667358221220d78cb4047b3907a7f2dd4dab13d5542ad887714825380b6619c247a5b79565d064736f6c63430008070033'
+
+        let bytecodes = [
+            bytecodeRaw,
+            bytecodeOptimized
+        ];
+
+        await alot(bytecodes)
+            .forEachAsync(async bytecode => {
+                const evm = new EVM(bytecode);
+
+                await evm.prepair();
+
+                let getOpCodes = evm.getMethodOpcodes('get()');
+                let hasSStore = getOpCodes.opcodes.find(x => x.name === 'SSTORE');
+                eq_(hasSStore, null);
+                //console.log(getOpCodes.opcodes.map(x => x.name));
+
+                let incOpCodes = evm.getMethodOpcodes('inc()');
+                let incHasSStore = incOpCodes.opcodes.find(x => x.name === 'SSTORE');
+                //console.log(incOpCodes.opcodes.map(x => x.name));
+                notEq_(incHasSStore, null);
+            })
+            .toArrayAsync({ threads: 1 });
+    }
+})

package/test/generate/openzeppelin.spec.ts

@@ -0,0 +1,18 @@
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client';
+
+UTest({
+    async 'check generated openzeppelin contract' () {
+        let client = new PolyWeb3Client();
+        let address = '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063'
+        let erc20 = new ERC20(address, client);
+
+        let nameReq = erc20.$config({ send: 'manual', from: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063' }).name();
+        let totalSupplyReq = erc20.$config({ send: 'manual' }).totalSupply();
+
+        let [ name, totalSupply ] = await erc20.$executeBatch([nameReq, totalSupplyReq ]);
+
+        eq_(name, '(PoS) Dai Stablecoin');
+        gt_(totalSupply, 1000n);
+    }
+})

package/test/generate/slotreader.spec.ts

@@ -0,0 +1,34 @@
+import { File } from 'atma-io';
+import { $date } from '@dequanto/utils/$date';
+import { GeneratorStorageReader } from '@dequanto/gen/GeneratorStorageReader';
+import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client';
+import { ContractStorageReaderBase } from '@dequanto/contracts/ContractStorageReaderBase';
+
+declare let include;
+
+UTest({
+    $config: {
+        timeout: $date.parseTimespan('5min'),
+    },
+
+    async '!generate polygons WETH' () {
+        const path = './test/fixtures/scan/WETH.sol';
+        const gen = new GeneratorStorageReader();
+        const result = await gen.generate({
+            address: '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619',
+            name: 'WETH',
+            contractName: 'MaticWETH',
+            network: 'poly',
+            client: new PolyWeb3Client(),
+            sources: {
+                [ path ]: {
+                    content: await File.readAsync(path)
+                }
+            }
+        });
+        global.ContractStorageReaderBase = ContractStorageReaderBase;
+
+        has_(result.code, 'class WETHStorageReader');
+        has_(result.code, '$slots = [');
+    }
+})

package/test/hardhat/TestNode.ts

@@ -1,7 +1,12 @@
 import memd from 'memd';
+import hre from "hardhat";
+
 import { HardhatWeb3Client } from '@dequanto/clients/HardhatWeb3Client';
 import { Socket } from 'net';
 import { Shell } from 'shellbee'
+import { $config } from '@dequanto/utils/$config';
+import { $promise } from '@dequanto/utils/$promise';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
 
 const PORT = `8545`;
 const HOST = `http://127.0.0.1:${PORT}/`
@@ -10,24 +15,48 @@ export class TestNode {
     static PORT = PORT
     static HOST = HOST
 
+    @memd.deco.memoize()
     static async client () {
-        await TestNode.start();
-        return HardhatWeb3Client.url(HOST);
+        //> in-memory
+        const web3 = (hre as any).web3;
+
+
+        // clean default configuration
+        $config.set('web3.hardhat.endpoints', []);
+
+        const client = new HardhatWeb3Client({ web3, chainId: 1337 });
+        return client;
+
+        //> localhost
+        // await TestNode.start();
+        // return HardhatWeb3Client.url(HOST, { chainId: 1337 });
     }
 
     @memd.deco.memoize()
     static async start () {
-        if (await isPortBusy(PORT) === false) {
-
-            let shell = await Shell.run({
-                command: 'npx hardhat node',
-                matchReady: /Started HTTP/i
+        if (await isPortBusy(PORT) === false || await isServerRunning() === false) {
+            let shell = new Shell({
+                command: 'node --openssl-legacy-provider ./node_modules/hardhat/internal/cli/cli.js node --hostname 127.0.0.1',
+                matchReady: /Started HTTP/i,
+                silent: true
             });
+            shell.run();
             await shell.onReadyAsync();
         }
     }
 }
 
+async function isServerRunning () {
+    let provider = new HardhatProvider();
+    let client = provider.client('localhost');
+    try {
+        let nr = await client.getBlockNumber();
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
 async function isPortBusy(port) {
 
     return new Promise((resolve, reject) => {
@@ -38,7 +67,6 @@ async function isPortBusy(port) {
             socket.destroy();
         };
 
-
         setTimeout(timeout, 500);
         socket.on("timeout", timeout);
 
@@ -48,7 +76,7 @@ async function isPortBusy(port) {
         });
 
         socket.on("error", function (exception: any) {
-            if (exception.code !== "ECONNREFUSED") {
+            if (exception.code === "ECONNREFUSED" || exception.code === "ECONNRESET") {
                 resolve(false);
             } else {
                 socket.destroy();

package/test/hardhat/deploy.spec.ts

@@ -0,0 +1,22 @@
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+
+
+UTest({
+    async 'should deploy solidity contract' () {
+        let provider = new HardhatProvider();
+
+        let { contract, abi } = await provider.deploySol('/test/fixtures/contracts/Foo.sol', {
+            arguments: [ 'Lorem' ]
+        });
+
+        let name = await contract.getName();
+        eq_(name, 'Lorem');
+
+        let tx = await contract.setName('Ipsum');
+        let receipt = await tx.wait();
+        eq_(receipt.transactionHash, tx.hash);
+
+        name = await contract.getName();
+        eq_(name, 'Ipsum');
+    }
+});

package/test/indexer/BlocksWalker.spec.ts

@@ -0,0 +1,51 @@
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { BlocksWalker } from '@dequanto/indexer/handlers/BlocksWalker';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { TestNode } from '../hardhat/TestNode';
+
+UTest({
+
+    async 'walk over sent simple transactions to get the blocks, txs, and receipts' () {
+        let provider = new HardhatProvider();
+        let client = await TestNode.client();
+
+        let acc1 = provider.deployer(1);
+        let acc2 = provider.deployer(2);
+
+
+        let w1 = await TxWriter.writeTxData(client, { to: acc2.address, value: 2n, }, acc1);
+        let r1 = await w1.wait();
+
+        let w2 = await TxWriter.writeTxData(client, { to: acc2.address, value: 3n, }, acc1);
+        let r2 = await w2.wait();
+
+        let blockNumber = await client.getBlockNumber();
+        eq_(r2.blockNumber, blockNumber);
+
+        let arr = [] as { block, txs?, receipts? } []
+        let walker = new BlocksWalker({
+            client,
+            name: 'test',
+            loadTransactions: true,
+            loadReceipts: true,
+            async visitor (block, data) {
+                arr.push({ block, ...data });
+            }
+        });
+
+        await walker.start(0);
+        await walker.onEndPromise;
+
+        eq_(arr.length, blockNumber + 1);
+
+        eq_(arr[arr.length - 1].block.number, r2.blockNumber);
+        eq_(arr[arr.length - 1].txs.length, 1);
+        eq_(arr[arr.length - 1].txs[0].hash, r2.transactionHash);
+
+        eq_(arr[arr.length - 1].receipts.length, 1);
+        eq_(arr[arr.length - 1].receipts[0].status, r2.status);
+        eq_(arr[arr.length - 1].receipts[0].transactionHash, r2.transactionHash);
+    }
+
+})

package/test/ns.spec.ts

@@ -6,6 +6,10 @@ UTest({
 
 
     'ens': {
+        async 'tld' () {
+            let hash = $ns.namehash('eth');
+            eq_(hash, '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae');
+        },
         async 'namehash' () {
             let hash = $ns.namehash('alice.eth');
             eq_(hash, `0x787192fc5378cc32aa956ddfdedbf26b24e8d78e40109add0eea2c1a012c3dec`);

package/test/receipt.spec.ts

@@ -1,7 +1,6 @@
+import di from 'a-di';
 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';
 
@@ -19,8 +18,6 @@ UTest({
 
         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);
     }