dequanto 0.0.1 → 0.1.3

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/flashbots/flashbots.spec.ts

@@ -0,0 +1,79 @@
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20'
+import { ChainAccountService } from '@dequanto/ChainAccountService';
+import { Config } from '@dequanto/config/Config';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { FlashbotsProvider } from '@dequanto/flashbots/FlashbotsProvider';
+import { EoAccount } from '@dequanto/models/TAccount';
+import { $is } from '@dequanto/utils/$is';
+import memd from 'memd';
+
+// integration test
+
+UTest({
+    async '//integration test'() {
+        memd.fn.clearMemoized(Config.fetch);
+
+        const config = await Config.fetch({
+            configGlobal: 'test/config.yml',
+            dotenv: true,
+        });
+
+        const client = Web3ClientFactory.get('eth:goerli');
+        // WETH https://sepolia.etherscan.io/address/0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14
+        // WETH https://goerli.etherscan.io/address/0xb4fbf271143f4fbf7b91a5ded31805e42b2208d6
+        const TOKEN = ({
+            'eth:goerli': `0xb4fbf271143f4fbf7b91a5ded31805e42b2208d6`,
+            'eth:sepolia': `0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14`,
+        } as const)[ client.platform ];
+
+        const account = await ChainAccountService.get<EoAccount>('DequantoIntegrationAccount', { config })
+
+        if (account?.key == null) {
+            console.log(`Skip flashbots integration test because TEST_ACCOUNT_KEY is not set`);
+            return;
+        }
+
+        let balance = await client.getBalance(account.address);
+        if (balance < 10n ** 10n) {
+            console.log(`Skip flashbots integration test because account ${account.address} has low balance: ${balance}`);
+            return;
+        }
+        let flashbots = await FlashbotsProvider.create(client, account);
+
+        // some tx to test serialization and submission
+        let token = new ERC20(TOKEN, client);
+
+        return UTest({
+            async 'check send Bundle'() {
+                let { signed: txHex } = await token.$signed().approve(account, account.address, 700n);
+                let bundleHash = await flashbots.sendPrivateTransaction({
+                    tx: txHex,
+                });
+                console.log('Executed', bundleHash);
+                eq_($is.Hex(bundleHash), true, `Not a valid bundle hash: ${bundleHash}`);
+            },
+            async 'check send MEV Bundle'() {
+                // some tx to test serialization and submission
+                let { signed: txHex } = await token.$signed().approve(account, account.address, 500n);
+
+                let simulated = await flashbots.simMevBundle({
+                    body: [ { tx: txHex } ],
+                });
+                eq_(simulated.success, true);
+
+                let executed = await flashbots.sendMevBundle({
+                    body: [ { tx: txHex } ],
+                });
+                eq_($is.Hex(executed.bundleHash), true, `Not a valid bundle hash: ${executed.bundleHash}`);
+                eq_($is.Hex(executed.block), true, `Not a valid block: ${executed.bundleHash}`);
+
+                console.log('Executed', executed);
+                let status = await flashbots.getBundleStats({
+                    bundleHash: executed.bundleHash,
+                    blockNumber: executed.block,
+                });
+                console.log('Status', status);
+            },
+        })
+    }
+})

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 { $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 { ContractWriter } from '@dequanto/contracts/ContractWriter';
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import alot from 'alot';
+import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
+
+declare let include;
 
 UTest({
-    async 'generate test' () {
-        let genPath = `/test/tmp/polygon/DaiTokenContractBase.ts`
+    $config: {
+        timeout: $date.parseTimespan('5min'),
+    },
+
+    async $before () {
+        await TestNode.start();
+        ContractWriter.SILENT = true;
+    },
+
+    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: ERC20 & { storage } = new WETH.WETH();
+        let decimals = await weth.decimals();
+        eq_(decimals, 18);
+
+        '> read in batch'
+
+        let nameReq = await weth
+            .$config({ send: 'manual' })
+            .name();
+
+        let totalSupplyReq = 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,238 @@ 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' () {
+
+        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');
+
+        return UTest({
+            $config: {
+                timeout: $date.parseTimespan('1min'),
+            },
+            async 'deploy to localhost to listen for WS events' () {
+                let provider = new HardhatProvider();
+                let client = await provider.client('localhost');
+                let { contract: foo }= await provider.deployClass<any>(Foo.Foo, {
+                    arguments: [ 'hello' ],
+                    client
+                });
+
+                let name = await foo.name();
+                eq_(name, 'hello');
+
+                l`> check storage simple`;
+                let nameFromSlot = await foo.storage.name();
+                eq_(nameFromSlot, 'hello');
+
+                l`> check storage nested`
+                let user = await foo.storage.user();
+                deepEq_(user, {
+                    account: '0x0000000000000000000000000000000000000001',
+                    amount: 50n
+                })
+
+                l`> Deploy second contract`;
+                let { contract: qux } = await provider.deployClass<any>(Foo.Foo, {
+                    arguments: [ 'qux' ],
+                    client
+                });
+
+                l`> Getting name`;
+                let nameBar = await qux.name();
+                eq_(nameBar, 'qux');
+                notEq_(foo.address, qux.address);
+
+                l`> Update qux contract and check later the event is not included in logs`
+                let quxTx = await qux.setName(provider.deployer(), 'Qux2');
+                let quxReceipt = await quxTx.wait();
+                eq_(quxReceipt.status, true);
+
+
+                l`> Get name with Contract Reader`
+                let reader = new ContractReader(client);
+                let nameFromReader = await reader.readAsync(foo.address, 'name() returns (string)');
+                eq_(nameFromReader, 'hello');
+
+                l`> Get name with Contract Reader and method SIGNATURE`
+                let nameFromReaderWithSig = await reader.readAsync(foo.address, '0x06fdde03() returns (string)');
+                eq_(nameFromReaderWithSig, 'hello');
+
+                l`> Subscribe to transactions stream`
+                const transactionsListener = [];
+                let subjectStream = foo.$onTransaction({ filter: { method: '*' } });
+                subjectStream.subscribe((data) => {
+                    transactionsListener.push(data.calldata);
+                });
+                await subjectStream.onConnected;
+
+
+                l`> Set new name (block ${ await client.getBlockNumber() })`
+                let tx = await foo.setName(provider.deployer(), 'bar');
+                let receipt = await tx.wait();
+                eq_(receipt.status, true);
+
+                l`> Check name was set (block ${ await client.getBlockNumber() })`
+                name = await foo.name();
+                eq_(name, 'bar');
+
+                l`> Set new name via setName2`
+                let txSetName2 = await foo.setName2(provider.deployer(), 'bar2');
+                await txSetName2.wait();
+                l`> Check name was set (block ${ await client.getBlockNumber() })`
+                name = await foo.name();
+                eq_(name, 'bar2');
+
+                l`> Check logs for FOO contract`
+                let logs = await foo.getPastLogsUpdated({});
+                gte_(logs.length, 1);
+                eq_(logs.find(log => log.params.newName == 'Qux2'), null);
+
+                let log = logs[logs.length - 1];
+                eq_(log.transactionHash, tx.tx.hash);
+                eq_(log.event, 'Updated');
+                eq_(log.params.newName, 'bar');
+
+                l`> Check logs for FOO contract with Event Name`;
+                let logsByName = await foo.getPastLogs('Updated');
+                deepEq_(logs, logsByName);
+
+                l`> Check logs by topic`
+                let parsed = await reader.getLogsParsed('event Updated(string newName)', {
+                    fromBlock: quxReceipt.blockNumber,
+                });
+                let names = parsed.map(x => x.params.newName);
+                deepEq_(names, ['Qux2', 'bar']);
+
+
+                l`> Emit logs again, and recheck fromBlock`;
+                let blockNr = await client.getBlockNumber();
+                tx = await foo.setName(provider.deployer(), 'qux');
+                receipt = await tx.wait();
+
+                eq_(typeof receipt.blockNumber, 'number');
+                eq_(blockNr + 1, receipt.blockNumber);
+                logs = await foo.getPastLogsUpdated({
+                    fromBlock: blockNr + 1
+                });
+                eq_(logs.length, 1);
+                eq_(logs[0].params.newName, 'qux');
+                eq_(typeof logs[0].blockNumber, 'number');
+
+
+
+                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 > 2, {
+                    timeoutMessage: () => `Transactions were not captured. Got ${transactionsListener.length} Expected: 2`,
+                    timeoutMs: 4000,
+                    intervalMs: 100,
+                });
+
+                let methods = transactionsListener.map(x => x.method);
+                deepEq_(methods, [
+                    // 3 set TX were emitted above
+                    'setName',
+                    'setName2',
+                    'setName',
+                ]);
+
+                let allLogs = await foo.$getPastLogsParsed('*') as ITxLogItem[];
+                let allEvents = alot(allLogs).map(x => x.event).distinct().toArray();
+                deepEq_(allEvents, [ 'Updated', 'Updated2']);
+
+                let allLogsByName = await foo.getPastLogs(['Updated', 'Updated2']);
+                deepEq_(allLogs, allLogsByName);
+            },
+
+            async 'deploy and check indexed logs' () {
+                let provider = new HardhatProvider();
+                // use in-memory, as is enough
+                let client = await provider.client('hardhat');
+                let { contract: foo } = await provider.deployClass<any>(Foo.Foo, {
+                    arguments: [ 'hello' ],
+                    client
+                });
+
+                let deployer = provider.deployer();
+                let value = Date.now();
+                l`Emit and fetch simple Logs`;
+                let tx = await foo.shouldEmitIndexedNormal(deployer, value, 4)
+                await tx.wait();
+                tx = await foo.shouldEmitIndexedNormal(deployer, value + 1, 6)
+                await tx.wait();
+
+                let logs = await foo.getPastLogsIndexedNormal({
+                    params: { valueA: value }
+                });
+                eq_(logs.length, 1);
+                eq_(logs[0].params.valueB, 4n);
+
+                let logs2nd = await foo.getPastLogsIndexedNormal({
+                    params: { valueA: value + 1 }
+                });
+                eq_(logs2nd.length, 1);
+                eq_(logs2nd[0].params.valueB, 6n);
+            },
+
+            async 'deploy and check indexed logs with index not-linear parameter order' () {
+                let provider = new HardhatProvider();
+                // use in-memory, as is enough
+                let client = await provider.client('hardhat');
+                let { contract: foo } = await provider.deployClass<any>(Foo.Foo, {
+                    arguments: [ 'hello' ],
+                    client
+                });
+
+
+                let deployer = provider.deployer();
+                let value = Date.now();
+                l`Emit and fetch simple Logs`;
+                let tx = await foo.shouldEmitIndexedWithOffset(deployer, 10, value, 10)
+                await tx.wait();
+                tx = await foo.shouldEmitIndexedWithOffset(deployer, 11, value + 1)
+                await tx.wait();
+
+                let logs = await foo.getPastLogsIndexedWithOffset({
+                    params: { valueB: value }
+                });
+                eq_(logs.length, 1);
+                eq_(logs[0].params.valueA, 10n);
+
+                let logs2nd = await foo.getPastLogsIndexedWithOffset({
+                    params: { valueB: value + 1 }
+                });
+                eq_(logs2nd.length, 1);
+                eq_(logs2nd[0].params.valueA, 11n);
+            }
+        })
+    },
 })

package/test/generate/evm.spec.ts

@@ -0,0 +1,71 @@
+import { EvmBytecode } from '@dequanto/evm/EvmBytecode';
+import { TEth } from '@dequanto/models/TEth';
+import alot from 'alot';
+
+UTest({
+    async 'parse the bytecode of a proxy contract' () {
+        let bytecode = `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` as const;
+        let evm = new EvmBytecode(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'
+        });
+
+        let isInterface = await evm.checkInterfaceOf([
+            'upgradeTo(address)',
+            'implementation()',
+        ]);
+        eq_(isInterface.ok, true);
+    },
+    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
+        ] as TEth.Hex[];
+
+        await alot(bytecodes)
+            .forEachAsync(async bytecode => {
+                const evm = new EvmBytecode(bytecode);
+
+                await evm.prepare();
+
+                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/gen.spec.ts

@@ -0,0 +1,69 @@
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { Generator } from '@dequanto/gen/Generator';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { l } from '@dequanto/utils/$logger';
+import { File } from 'atma-io';
+import { Constructor } from 'atma-utils';
+
+declare let include;
+
+UTest({
+    async 'generate and deploy from compiled json meta' () {
+
+        /** Test with absolute path, to prevent absolute paths in generated files */
+        const artifact = 'test/fixtures/artifacts/AnyERC20/AnyERC20.json'
+        const absPath = new File(artifact).uri.toString();
+        const gen = new Generator({
+            name: 'AnyERC20',
+            platform: 'hardhat',
+            source: {
+                path: absPath
+            },
+            output: './test/tmp/hardhat/'
+        });
+        await gen.generate();
+
+
+        let path = '/test/tmp/hardhat/AnyERC20/AnyERC20.ts';
+        let source = await File.readAsync(path, { skipHooks: true });
+        has_(source, `Implementation: test/fixtures/artifacts/AnyERC20/AnyERC20.sol`);
+
+        let { AnyERC20 } = await include.js(path);
+        let Ctor = AnyERC20.AnyERC20 as Constructor<ERC20>;
+
+        eq_(new Ctor().$meta.artifact, artifact);
+
+        l`> deploy contract`
+        let hh = new HardhatProvider();
+
+        let { contract } = await hh.deployClass(Ctor, {
+            arguments: [
+                'Foo Token',
+                'Foo',
+                1000
+            ]
+        });
+
+        eq_(await contract.symbol(), 'Foo');
+    },
+    async 'generate from solidity file by parsing into abi' () {
+        const gen = new Generator({
+            name: 'IERC4626',
+            platform: 'hardhat',
+            source: {
+                path: '@openzeppelin/contracts/interfaces/IERC4626.sol'
+            },
+            output: './test/tmp/hardhat/'
+        });
+        await gen.generate();
+
+        let path = '/test/tmp/hardhat/IERC4626/IERC4626.ts';
+        let { IERC4626 } = await include.js(path);
+        let Ctor = IERC4626.IERC4626 as Constructor<any>;
+        let x = new Ctor();
+
+        eq_(typeof x.asset, 'function');
+        eq_(x.$meta.class, './test/tmp/hardhat/IERC4626/IERC4626.ts');
+        eq_(x.$meta.source, '@openzeppelin/contracts/interfaces/IERC4626.sol');
+    }
+})

package/test/generate/openzeppelin.spec.ts

@@ -0,0 +1,22 @@
+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` as const;
+        let erc20 = new ERC20(address, client);
+
+        let nameReq = erc20.$config({ from: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063' }).$req().name();
+        let totalSupplyReq = erc20.$req().totalSupply();
+        let balanceReq = erc20.$req().balanceOf(address);
+
+        let [ name, totalSupply, balance ] = await erc20.$executeBatch([nameReq, totalSupplyReq, balanceReq ]);
+
+
+        eq_(name, '(PoS) Dai Stablecoin');
+        gt_(totalSupply, 1000n);
+        gt_(balance, 1000n);
+
+    }
+})