dequanto 0.0.1 → 0.0.7

package/test/safe/tx.act.ts

@@ -0,0 +1,194 @@
+import { File } from 'atma-io';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { GnosisSafeFactory } from '@dequanto/safe/GnosisSafeFactory';
+import { GnosisSafe } from '@dequanto-contracts/gnosis/GnosisSafe';
+import { GnosisSafeHandler } from '@dequanto/safe/GnosisSafeHandler';
+import { InMemoryServiceTransport } from '@dequanto/safe/transport/InMemoryServiceTransport';
+import { ContractWriter } from '@dequanto/contracts/ContractWriter';
+import { SafeAccount } from '@dequanto/models/TAccount';
+import { FileServiceTransport } from '@dequanto/safe/transport/FileServiceTransport';
+import { $signRaw } from '@dequanto/utils/$signRaw';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $promise } from '@dequanto/utils/$promise';
+import { $address } from '@dequanto/utils/$address';
+
+
+UTest({
+    async $before () {
+        try {
+            await File.removeAsync('./test/tmp/safe-tx.json');
+        } catch (error) { }
+    },
+    'should sign tx hash' () {
+        const key = `0x66e91912f68828c17ad3fee506b7580c4cd19c7946d450b4b0823ac73badc878`;
+        const address = `0x6a2EB7F6734F4B79104A38Ad19F1c4311e5214c8`;
+        const txHash = `0x1ed9d878f89585977e98425d5cedf51027c041e414bb471d64519f8f510bb555`;
+
+        const signature = $signRaw.signEC(txHash, key);
+        eq_(signature.signature, `0xc0df6a1b659d56d3d23f66cbd1c483467ea68a428fea7bbbe0a527d43d8681f616af33344035f36c08218718480374dada0fe6cdb266d0182a4225d0e9c227181b`);
+
+        const addressBack = $signRaw.ecrecover(txHash, signature.signature);
+        eq_(addressBack, address);
+    },
+
+    async 'create in-memory safe and manully receive tokens ' () {
+        let provider = new HardhatProvider();
+        let client = provider.client();
+        let owner1 = provider.deployer();
+        let owner2 = provider.deployer(1);
+
+        let { safe, freeTokenContract } = await SafeTestableFactory.prepair();
+
+        eq_($address.isValid(safe.safeAddress), true, `Invalid address ${safe.safeAddress}`);
+
+        let contract = new GnosisSafe(safe.safeAddress, client);
+        let nonce = await contract.nonce();
+        eq_(Number(nonce), 0);
+
+
+        let handler = new GnosisSafeHandler({
+            safeAddress: safe.safeAddress,
+            owner: owner1,
+            client: client,
+            transport: new InMemoryServiceTransport(client, owner1)
+        });
+
+
+        let balanceBefore = await freeTokenContract.balanceOf(safe.safeAddress);
+        eq_($bigint.toEther(balanceBefore, 18), 0);
+
+
+        '> airdrop some tokens to sender (safe)'
+
+        let writer = new ContractWriter(freeTokenContract.address, client);
+        let txWriter = await writer.writeAsync(<SafeAccount>{
+            address: safe.safeAddress,
+            operator: owner1,
+        }, 'airdrop()', [], {
+            builderConfig: {
+                send: 'manual'
+            }
+        });
+
+        let { safeTxHash: hash, threshold } = await handler.createTransaction(txWriter, 0n);
+
+        await handler.confirmTx(hash, owner2);
+        await handler.confirmTx(hash, owner1);
+        let tx = await handler.submitTransaction(hash);
+
+        let receipt = await tx.wait();
+        eq_(receipt.status, true);
+
+        let balance = await freeTokenContract.balanceOf(safe.safeAddress);
+        let eth = $bigint.toEther(balance, 18);
+        eq_(eth, 10);
+
+
+        nonce = await contract.nonce();
+        eq_(Number(nonce), 1);
+    },
+
+    async 'create file safe and manully receive tokens ' () {
+        let provider = new HardhatProvider();
+        let client = provider.client();
+        let owner1 = provider.deployer();
+        let owner2 = provider.deployer(1);
+
+        let { safe, freeTokenContract } = await SafeTestableFactory.prepair();
+
+        eq_($address.isValid(safe.safeAddress), true, `Invalid address ${safe.safeAddress}`);
+
+        let contract = new GnosisSafe(safe.safeAddress, client);
+        let nonce = await contract.nonce();
+        eq_(Number(nonce), 0);
+
+
+        let balanceBefore = await freeTokenContract.balanceOf(safe.safeAddress);
+        eq_($bigint.toEther(balanceBefore, 18), 0);
+
+
+        '> airdrop some tokens to sender (safe)'
+
+        let writer = new ContractWriter(freeTokenContract.address, client);
+        let safeAccount = <SafeAccount>{
+            address: safe.safeAddress,
+            operator: owner1,
+        };
+
+        let confirmationsFile = './test/tmp/safe-tx.json';
+        let txWriter = await writer.writeAsync(safeAccount, 'airdrop()', [], {
+            writerConfig: {
+                safeTransport: new FileServiceTransport(client, owner1, confirmationsFile)
+            }
+        });
+
+        let safeTx = await $promise.fromEvent(txWriter, 'safeTxProposed');
+
+
+        let arr = await File.readAsync<any>(confirmationsFile);
+        let json = arr.find(x => x.safeTxHash === safeTx.safeTxHash);
+
+        eq_(json.safeTxHash, safeTx.safeTxHash);
+
+        let sig1 = $signRaw.signEC(safeTx.safeTxHash, owner1.key);
+        let sig2 = $signRaw.signEC(safeTx.safeTxHash, owner2.key);
+        json.confirmations = [
+            { owner: owner1.address, signature: sig1.signature },
+            { owner: owner2.address, signature: sig2.signature },
+        ];
+
+        await File.writeAsync(confirmationsFile, arr);
+
+
+        let receipt = await txWriter.wait();
+        eq_(receipt.status, true);
+
+        let balance = await freeTokenContract.balanceOf(safe.safeAddress);
+        let eth = $bigint.toEther(balance, 18);
+        eq_(eth, 10);
+
+        nonce = await contract.nonce();
+        eq_(Number(nonce), 1);
+    }
+})
+
+class SafeTestableFactory {
+
+    static async prepair () {
+        let provider = new HardhatProvider();
+        let client = provider.client();
+        let owner1 = provider.deployer();
+        let owner2 = provider.deployer(1);
+
+        const { contract: proxyFactoryContract, abi: proxyFactoryAbi } = await provider.deploySol('/test/fixtures/gnosis/proxies/GnosisSafeProxyFactory.sol');
+        const { contract: safeContract, abi: safeAbi } = await provider.deploySol('/test/fixtures/gnosis/GnosisSafe.sol');
+        const { contract: multiSendContract, abi: multiSendAbi } = await provider.deploySol('/test/fixtures/gnosis/libraries/MultiSend.sol');
+
+        let safe = await GnosisSafeFactory.create(owner1, client, {
+            owners: [
+                owner1.address,
+                owner2.address
+            ],
+            contracts: {
+                [client.chainId + '']: {
+                    multiSendAddress: multiSendContract.address,
+                    multiSendAbi: multiSendAbi,
+
+                    safeMasterCopyAddress: safeContract.address,
+                    safeMasterCopyAbi: safeAbi,
+
+                    safeProxyFactoryAbi: proxyFactoryAbi,
+                    safeProxyFactoryAddress: proxyFactoryContract.address
+                }
+            }
+        });
+
+        const { contract: freeTokenContract, abi: freeTokenAbi } = await provider.deploySol('/test/fixtures/contracts/FreeToken.sol', {
+            client
+        });
+
+        return {
+            safe, freeTokenContract
+        }
+    }
+}

package/test/solidity/SlotsParser.spec.ts

@@ -0,0 +1,186 @@
+import { SlotsParser } from '@dequanto/solidity/SlotsParser';
+
+UTest({
+    async 'should extract slots from contract' () {
+
+        const input = `
+            contract Test {
+                uint256 a; // 0x0
+                uint256[3] b; // 0x1-0x3
+                struct Data {
+                    uint256 id;
+                    uint256 value;
+                }
+                Data c; // 0x4-0x5
+                Data[] d; // 0x6
+
+                mapping(uint256 => uint256) e; // 0x7
+
+                bytes32 private f; // 0x8
+                bytes16 private g; // 0x9
+                bytes16 private h; // 0x9
+            }
+        `;
+
+        const slots = await SlotsParser.slots({
+            code: input,
+            path: './test/solidity/Parser.sol'
+        }, 'Test');
+
+        has_(slots[0], {
+            slot: 0,
+            position: 0,
+            name: 'a',
+            size: 256,
+            type: 'uint256'
+        });
+        has_(slots[1], {
+            slot: 1,
+            position: 0,
+            name: 'b',
+            size: 256 * 3,
+            type: 'uint256[3]'
+        });
+        has_(slots[2], {
+            slot: 4,
+            position: 0,
+            name: 'c',
+            size: 256 * 2,
+            type: '(uint256 id, uint256 value)'
+        });
+        has_(slots[3], {
+            slot: 6,
+            position: 0,
+            name: 'd',
+            size: Infinity,
+            type: '(uint256 id, uint256 value)[]'
+        });
+        has_(slots[4], {
+            slot: 7,
+            position: 0,
+            name: 'e',
+            size: Infinity,
+            type: 'mapping(uint256 => uint256)'
+        });
+        has_(slots[5], {
+            slot: 8,
+            position: 0,
+            name: 'f',
+            size: 256,
+            type: 'bytes32'
+        });
+        has_(slots[6], {
+            slot: 9,
+            position: 0,
+            name: 'g',
+            size: 128,
+            type: 'bytes16'
+        });
+        has_(slots[7], {
+            slot: 9,
+            position: 128,
+            name: 'h',
+            size: 128,
+            type: 'bytes16'
+        });
+    },
+    async 'should extract slots from abi' () {
+
+        const input = `
+            (uint256 foo, uint256[3] bar)
+        `;
+
+        const slots = await SlotsParser.slotsFromAbi(input);
+
+        has_(slots[0], {
+            slot: 0,
+            position: 0,
+            name: 'foo',
+            size: 256,
+            type: 'uint256'
+        });
+        has_(slots[1], {
+            slot: 1,
+            position: 0,
+            name: 'bar',
+            size: 256 * 3,
+            type: 'uint256[3]'
+        });
+    },
+    async 'should extract slots from inherited contracts' () {
+        const input = `
+            contract Foo {
+                uint a;
+                string b;
+            }
+            contract Test is Foo {
+                uint256 c;
+            }
+        `;
+
+        const slots = await SlotsParser.slots({
+            code: input,
+            path: './test/solidity/Parser.sol'
+        }, 'Test');
+
+        has_(slots[0], {
+            slot: 0,
+            name: 'a',
+            size: 256,
+            type: 'uint'
+        });
+        has_(slots[1], {
+            slot: 1,
+            name: 'b',
+            size: Infinity,
+            type: 'string'
+        });
+        has_(slots[2], {
+            slot: 2,
+            name: 'c',
+            size: 256,
+            type: 'uint256'
+        });
+    },
+    async 'should parse weth.sol' () {
+        let slots = await SlotsParser.slots({ path: './test/fixtures/scan/WETH.sol'}, 'MaticWETH');
+        let names = slots.map(x => x.name);
+        let types = slots.map(x => x.type);
+
+        eq_(names[0], '_balances');
+        eq_(types[0], 'mapping(address => uint256)');
+
+        eq_(names[1], '_allowances');
+        eq_(types[1], 'mapping(address => mapping(address => uint256))');
+
+
+        eq_(names[2], '_totalSupply');
+        eq_(types[2], 'uint256');
+
+
+        eq_(names[3], '_name');
+        eq_(types[3], 'string');
+
+        eq_(names[4], '_symbol');
+        eq_(types[4], 'string');
+
+        eq_(names[5], '_decimals');
+        eq_(types[5], 'uint8');
+
+        eq_(names[6], '_roles');
+        eq_(types[6], 'mapping(bytes32 => (((bytes32[] _values, mapping(bytes32 => uint256) _indexes) _inner) members, bytes32 adminRole))');
+
+        eq_(names[7], '_revertMsg');
+        eq_(types[7], 'string');
+
+        eq_(names[8], 'inited');
+        eq_(types[8], 'bool');
+
+        eq_(names[9], 'domainSeperator');
+        eq_(types[9], 'bytes32');
+
+        eq_(names[10], 'nonces');
+        eq_(types[10], 'mapping(address => uint256)');
+
+    }
+})

package/test/solidity/SlotsReader.spec.ts

@@ -0,0 +1,168 @@
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { SlotsParser } from '@dequanto/solidity/SlotsParser';
+import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
+import { $buffer } from '@dequanto/utils/$buffer';
+import { $hex } from '@dequanto/utils/$hex';
+import { l } from '@dequanto/utils/$logger';
+
+UTest({
+    async 'should read contracts storage'() {
+
+        let provider = new HardhatProvider();
+        let client = await provider.client();
+        let path = '/test/fixtures/slots/Vault.sol';
+
+        let hex = $buffer.toHex($buffer.fromString('hello'));
+
+        hex = $hex.padBytes(hex, 32, { padEnd: true });
+
+        let { contract, abi } = await provider.deploySol(path, { arguments: [ hex ], client });
+        let slots = await SlotsParser.slots({ path }, 'Vault');
+
+
+        let keys = slots.map(x => x.name);
+        deepEq_(keys, [
+            'count',
+            'owner',
+            'isTrue',
+            'u16',
+            'password',
+            'data',
+            'users',
+            'idToUser',
+            'dynamicSlotString',
+            'singleSlotString',
+        ]);
+
+        let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+        async function read(key) {
+            return await storage.get(key);
+        }
+        async function readArrItem(key, idx) {
+            return await storage.get(`${key}[${idx}]`);
+        }
+        function toString(hex) {
+            return $buffer.fromHex($hex.trimBytes(hex)).toString()
+        }
+
+        eq_(await read('count'), 123n);
+        eq_(await read('owner'), provider.deployer().address.toLowerCase());
+        eq_(await read('isTrue'), true);
+        eq_(await read('u16'), 31);
+
+
+        eq_(toString(await read('password')), 'hello');
+
+        eq_(toString(await readArrItem('data', 0)), 'one');
+        eq_(toString(await readArrItem('data', 1)), 'two');
+        eq_(toString(await readArrItem('data', 2)), 'three');
+
+        let user1 = await storage.get('users[0]');
+        eq_(user1.id, 0)
+        eq_(toString(user1.password), 'one');
+
+        let user2 = await storage.get('users[1]');
+        eq_(user2.id, 1)
+        eq_(toString(user2.password), 'two');
+
+        let user1Map = await storage.get('idToUser[0]');
+        eq_(user1Map.id, 0)
+        eq_(toString(user1Map.password), 'one');
+
+
+        let user2Map = await storage.get('idToUser[1]');
+        eq_(user2Map.id, 1)
+        eq_(toString(user2Map.password), 'two');
+
+        let singleSlotString = await storage.get('singleSlotString');
+        eq_(singleSlotString, 'hello')
+
+        let dynamicSlotString = await storage.get('dynamicSlotString');
+        eq_(dynamicSlotString, '0123456789012345678901234567890123456789012345678901234567890')
+    },
+
+    async 'should read from contracts with inheritance'() {
+
+        let provider = new HardhatProvider();
+        let client = await provider.client();
+        let path = '/test/fixtures/slots/FooStorage.sol';
+
+
+        let { contract, abi } = await provider.deploySol(path, { client });
+        let slots = await SlotsParser.slots({ path }, 'FooStorage');
+
+        let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+        eq_(await storage.get('fooBase'), 1n)
+        eq_(await storage.get('foo'), 2n)
+    },
+
+    'arrays': {
+        async 'should read packed flags from single slot' () {
+            let code = `
+                contract Counter {
+                    bool public flag = true;
+                    bool[3] public flags = [ true, true, true ];
+                    uint128[3] public halfs = [1, 2, 3];
+                    uint256[2] public nums = [4, 5];
+                }
+            `;
+
+            let provider = new HardhatProvider();
+            let client = await provider.client();
+
+            let { contract, abi } = await provider.deployCode(code, { client });
+
+
+
+            let flag = await contract.flag();
+            eq_(flag, true);
+
+            l`Read with ABI`
+            let flags = await Promise.all([
+                contract.flags(0),
+                contract.flags(1),
+                contract.flags(2),
+            ]);
+            deepEq_(flags, [ true, true, true ]);
+
+            l`Read with SLOTS Readers`
+            let slots = await SlotsParser.slots({ path: '', code });
+
+            deepEq_(slots[0], { slot: 0, size: 8, position: 0, type: 'bool', name: 'flag' });
+            deepEq_(slots[1], { slot: 1, size: 24, position: 0, type: 'bool[3]', name: 'flags' });
+
+            let storage = SlotsStorage.createWithClient(client, contract.address, slots);
+
+
+            l`Read single boolean`
+            flag = await storage.get('flag')
+            eq_(flag, true);
+
+            l`Read fixed size boolean array`
+            flags = await Promise.all([
+                storage.get('flags[0]'),
+                storage.get('flags[1]'),
+                storage.get('flags[2]'),
+            ]);
+            deepEq_(flags, [ true, true, true ]);
+
+            l`Read fixed size num array`
+            let halfs = await Promise.all([
+                storage.get('halfs[0]'),
+                storage.get('halfs[1]'),
+                storage.get('halfs[2]'),
+            ]);
+
+            deepEq_(halfs, [ 1n, 2n, 3n ]);
+
+            l`Read fixed size num array`
+            let nums = await Promise.all([
+                storage.get('nums[0]'),
+                storage.get('nums[1]'),
+            ]);
+            deepEq_(nums, [ 4n, 5n]);
+        }
+    }
+})