dequanto 0.0.1 → 0.0.7

package/test/Batch.spec.ts

@@ -0,0 +1,89 @@
+import { Wallet } from 'ethers';
+import { l } from '@dequanto/utils/$logger';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $contract } from '@dequanto/utils/$contract';
+import { $txData } from '@dequanto/utils/$txData';
+import { TestNode } from './hardhat/TestNode';
+
+UTest({
+    $config: {
+        timeout: 20_000
+    },
+    async $before () {
+        await TestNode.start();
+    },
+    async 'check balances' () {
+        let provider = new HardhatProvider();
+        let client = await provider.client('localhost');
+
+        let acc1 = provider.deployer(1);
+        let acc2 = provider.deployer(2);
+
+        let balancesBatched = await client.getBalances([
+            acc1.address,
+            acc2.address,
+        ]);
+        let balancesSingle = await Promise.all([
+            client.getBalance(acc1.address),
+            client.getBalance(acc2.address),
+        ]);
+
+        eq_(balancesBatched[0], balancesSingle[0]);
+        eq_(balancesBatched[1], balancesSingle[1]);
+
+    },
+    async 'check subscriptions and batch tx resolver' () {
+
+        let provider = new HardhatProvider();
+        let client = await provider.client('localhost');
+
+        let acc1 = provider.deployer(1);
+        let acc2 = provider.deployer(2);
+
+        l`Subscribe to pending transactions`
+        client.subscribe('pendingTransactions', <any> assert.await(2));
+
+        let builder = new TxDataBuilder(client, acc1, {
+            to: acc2.address,
+            value: $bigint.toWei(1)
+        });
+        await Promise.all([
+            builder.setNonce(),
+            builder.setGas(),
+        ]);
+
+        let writer = TxWriter.create(client, builder, acc1);
+
+        l`Manually check the tx HASH later`
+        let wallet = new Wallet(acc1.key);
+        let json = $txData.getJson(builder.getTxData(client) as any);
+        let txSigned = await wallet.signTransaction(json);
+        let txHash = $contract.keccak256(txSigned);
+
+        let r1 = await writer.send().wait();
+        eq_(r1.transactionHash, txHash);
+
+        let r2 = await (await writer.transferNative(acc1, acc2.address, $bigint.toWei(2))).wait();
+
+        l`Get Transactions`
+        let txs = await client.getTransactions([r1.transactionHash, r2.transactionHash]);
+
+        eq_(txs[0].hash, r1.transactionHash);
+        eq_(txs[1].hash, r2.transactionHash);
+
+        l`Get Receipts`
+        let receipts = await client.getTransactionReceipts([r1.transactionHash, r2.transactionHash])
+        eq_(receipts[0].transactionHash, r1.transactionHash);
+        eq_(receipts[1].transactionHash, r2.transactionHash);
+
+        l`Get Blocks`
+        let blocks = await client.getBlocks([0,1]);
+        eq_(blocks.length, 2);
+
+        eq_(blocks[0].number, 0);
+        eq_(blocks[1].number, 1);
+    }
+})

package/test/BlockChainExplorer.spec.ts

@@ -0,0 +1,33 @@
+import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan';
+import { File } from 'atma-io'
+import axios from 'axios';
+
+const ax = axios as any;
+
+UTest({
+    async $before () {
+        ax.getOriginal = ax.get;
+        ax.get = async function (url, ...args) {
+            if (url.includes('address/0xfbD2aa7efA2B46Ce3c58D7ab0D92C176c71499C0')) {
+                return {
+                    status: 200,
+                    data: await File.readAsync<string>('./test/fixtures/explorer/0xfbD2aa7efA2B46Ce3c58D7ab0D92C176c71499C0.html'),
+                    headers: {
+                        'Content-Type': 'text/html'
+                    }
+                };
+            }
+            return ax.getOriginal(url, ...args);
+        };
+    },
+    async $after () {
+        ax.get = ax.getOriginal;
+    },
+
+    async 'should fetch ABI by similar ByteCode' () {
+        let bscscan = new Bscscan();
+        let { abi } = await bscscan.getContractAbi('0xfbD2aa7efA2B46Ce3c58D7ab0D92C176c71499C0');
+        eq_(typeof abi, 'string');
+        has_(abi, 'uint256');
+    }
+})

package/test/ChainAccount.spec.ts

@@ -1,4 +1,4 @@
-import { ChainAccountProvider } from '@dequanto/ChainAccounts'
+import { ChainAccountProvider } from '@dequanto/ChainAccountProvider'
 
 
 UTest({

package/test/client.spec.ts

@@ -10,15 +10,16 @@ const Accounts = [
         address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
         key: '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
     }
-]
+];
+
 UTest({
     async 'get block' () {
-        let client = await TestNode.client()
-        let block = await client.getBlockNumber()
+        let client = await TestNode.client();
+        let block = await client.getBlockNumber();
         gte_(block, 0);
     },
     async 'check balance' () {
-        let client = await TestNode.client()
+        let client = await TestNode.client();
         let balance = await client.getBalance('0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266');
         lte_(balance, 10000n * 10n ** 18n);
     },
@@ -32,7 +33,7 @@ UTest({
         });
 
         await tx.setGas();
-        gte_(BigInt(tx.data.gasPrice as string), 10n ** 8n);
+        gte_(BigInt(tx.data.maxFeePerGas as string), 10n ** 8n);
 
         await tx.setNonce();
         gte_(Number(tx.data.nonce), 0);
@@ -40,13 +41,9 @@ UTest({
         let amount = 10n * 10n ** 18n;
         tx.setValue(amount);
 
-        let message = tx.signToString(from.key);
+        let message = await tx.signToString(from.key);
         let promi = client.sendSignedTransaction(message)
 
-        // promi.on('transactionHash', assert.await());
-        // promi.on('error', error => console.log('error', error));
-        // promi.on('confirmation', confirmation => console.log('confirmation', confirmation));
-        // promi.on('receipt', receipt => console.log('receipt', receipt));
 
         let receipt = await promi;
 
@@ -54,6 +51,8 @@ UTest({
         eq_(before + amount, after);
 
         let txMined = await client.getTransaction(receipt.transactionHash);
-        eq_(txMined.gasPrice, tx.data.gasPrice);
+
+        gt_(Number(tx.data.maxFeePerGas), 1000_000_000)
+        lt_(Number(txMined.gasPrice), Number(tx.data.maxFeePerGas));
     }
 })

package/test/config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    suites: {
+        selenium : {
+            exec: 'node',
+            tests: 'test/**.spec.ts'
+        }
+    }
+};

package/test/config.spec.ts

@@ -0,0 +1,31 @@
+import { $config } from '@dequanto/utils/$config';
+
+UTest({
+    $after () {
+        $config.reloadEnv();
+
+        let val = $config.get('settings.base');
+        eq_(val ?? './', './');
+    },
+    async 'get value from cli' () {
+        $config.reloadEnv(['--config', '"settings.base=foo"']);
+        let val = $config.get('settings.base');
+        eq_(val, 'foo');
+    },
+    async 'get value from cli single' () {
+
+        $config.reloadEnv(["--config='settings.base=./'"]);
+
+        let val = $config.get('settings.base');
+        eq_(val, './');
+    },
+    async 'get value from ENV' () {
+
+        $config.reloadEnv([], {
+            ['DQ_SETTINGS__BASE']: 'boom'
+        });
+
+        let val = $config.get('settings.base');
+        eq_(val, 'boom');
+    }
+})

package/test/ecrecover.spec.ts

@@ -0,0 +1,49 @@
+import { ChainAccountProvider } from '@dequanto/ChainAccountProvider';
+import { ContractReader } from '@dequanto/contracts/ContractReader';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { $contract } from '@dequanto/utils/$contract';
+import { $signRaw } from '@dequanto/utils/$signRaw';
+
+UTest({
+    async 'should sign a message'() {
+        let amount = 9n;
+        let nonce = 1;
+        let signer = ChainAccountProvider.generate();
+        let user = ChainAccountProvider.generate();
+
+
+        let hardhat = new HardhatProvider();
+        let client = hardhat.client();
+        let { contract, abi } = await hardhat.deploySol('/test/fixtures/contracts/Ecrecover.sol');
+
+
+        let encodedParams = $abiUtils.encode([
+            'address',
+            'uint256',
+            'uint8',
+        ], [
+            user.address,
+            amount,
+            nonce
+        ]);
+
+        let hash = $contract.keccak256(encodedParams);
+        let { v, r, s } = await $signRaw.signEC(hash, signer.key);
+
+        let reader = new ContractReader(client);
+        let isValid = await reader.readAsync(
+            contract.address,
+            'function isValid (address owner, uint256 amount, uint8 nonce, uint8 v, bytes32 r, bytes32 s, address signer) returns bool',
+            user.address,
+            amount,
+            nonce,
+            v,
+            r,
+            s,
+            signer.address
+        );
+
+        eq_(isValid, true);
+    }
+});

package/test/fixtures/contracts/Counter.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+contract Counter {
+    uint public count;
+
+    // Function to get the current count
+    function get() public view returns (uint) {
+        return count;
+    }
+
+    // Function to increment count by 1
+    function inc() public {
+        count += 1;
+    }
+
+    // Function to decrement count by 1
+    function dec() public {
+        count -= 1;
+    }
+
+    function set(uint value) public {
+        count = value;
+    }
+}

package/test/fixtures/contracts/Ecrecover.sol

@@ -0,0 +1,33 @@
+pragma solidity ^0.8.2;
+
+import "hardhat/console.sol";
+
+contract Ecrecover {
+
+    address public _owner;
+    mapping(address => uint8) nonces;
+
+    constructor() {
+        _owner = msg.sender;
+    }
+
+
+    function isValid (address user, uint256 amount, uint8 nonce, uint8 v, bytes32 r, bytes32 s, address signer) public view returns (bool) {
+
+        bytes memory hashStructRaw = abi.encode(
+            user,
+            amount,
+            nonce
+        );
+
+        bytes32 hashStruct = keccak256(hashStructRaw);
+
+        console.log("[hardhat] >");
+        console.logBytes(abi.encodePacked(hashStruct));
+
+
+        address signerRecovered = ecrecover(hashStruct, v, r, s);
+        console.log("[hardhat] signerRecovered", signerRecovered);
+        return signerRecovered == signer;
+    }
+}

package/test/fixtures/contracts/Foo.sol

@@ -0,0 +1,32 @@
+pragma solidity ^0.8.2;
+
+contract Foo {
+    string public name;
+    event Updated (string newName);
+    event Updated2 (string newName);
+
+    constructor(string memory _name) {
+        name = _name;
+    }
+
+    function setName(string memory _name) public {
+        name = _name;
+        emit Updated(name);
+    }
+    function setName2(string memory _name) public {
+        name = _name;
+        emit Updated2(name);
+    }
+
+    function getName () public view returns (string memory) {
+        return name;
+    }
+
+
+    function someEcho () public pure returns (uint8) {
+        return 0;
+    }
+    function someEcho (uint8 val) public pure returns (uint8) {
+        return val;
+    }
+}

package/test/fixtures/contracts/Foo.ts

@@ -0,0 +1,78 @@
+/**
+ *  AUTO-Generated Class: 2022-07-12 23:33
+ *  Implementation: https://etherscan.io/address/undefined#code
+ */
+import di from 'a-di';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TAccount } from '@dequanto/models/TAccount';
+import { TBufferLike } from '@dequanto/models/TBufferLike';
+import { ClientEventsStream } from '@dequanto/clients/ClientEventsStream';
+import { ContractBase } from '@dequanto/contracts/ContractBase';
+import { type AbiItem } from 'web3-utils';
+import { TransactionReceipt, EventLog } from 'web3-core';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan'
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'
+export class Foo extends ContractBase {
+    constructor(
+        public address: TAddress = '',
+        public client: Web3Client = di.resolve(EthWeb3Client),
+        public explorer: IBlockChainExplorer = di.resolve(Etherscan)
+    ) {
+        super(address, client, explorer)
+    }
+
+    // 0x17d7de7c
+    async getName (): Promise<string> {
+        return this.$read('function getName() returns string');
+    }
+
+    // 0x06fdde03
+    async name (): Promise<string> {
+        return this.$read('function name() returns string');
+    }
+
+    // 0xc47f0027
+    async setName (sender: TSender, _name: string): Promise<TxWriter> {
+        return this.$write(this.$getAbiItem('function', 'setName'), sender, _name);
+    }
+
+    onUpdated (fn: (event: EventLog, newName: string) => void): ClientEventsStream<any> {
+        return this.$on('Updated', fn);
+    }
+
+    extractLogsUpdated (tx: TransactionReceipt): ITxLogItem<TLogUpdated>[] {
+        let abi = this.$getAbiItem('event', 'Updated');
+        return this.$extractLogs(tx, abi) as any as ITxLogItem<TLogUpdated>[];
+    }
+
+    async getPastLogsUpdated (options?: {
+        fromBlock?: number | Date
+        toBlock?: number | Date
+        params?: {  }
+    }): Promise<ITxLogItem<TLogUpdated>[]> {
+        let topic = '0x221d3d4161ff7c815e25a84cf3c2ec04f54111bee80f0b06d345c834581c9da3';
+        let abi = this.$getAbiItem('event', 'Updated');
+        let filters = await this.$getPastLogsFilters(abi, {
+            topic,
+            ...options
+        });
+        let logs= await this.$getPastLogs(filters);
+        return logs.map(log => this.$extractLog(log, abi)) as any;
+    }
+
+    abi = [{"inputs":[{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"newName","type":"string"}],"name":"Updated","type":"event"},{"inputs":[],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"}],"name":"setName","outputs":[],"stateMutability":"nonpayable","type":"function"}]
+}
+
+type TSender = TAccount & {
+    value?: string | number | bigint
+}
+
+    type TLogUpdated = {
+        newName: string
+    }
+