dequanto 0.0.1 → 0.0.7

package/src/txs/sig-transports/SigFileTransport.ts

@@ -0,0 +1,52 @@
+import { $fn } from '@dequanto/utils/$fn';
+import { $logger } from '@dequanto/utils/$logger';
+import { $sign } from '@dequanto/utils/$sign';
+import { $txData } from '@dequanto/utils/$txData';
+import { File } from 'atma-io'
+import { utils } from 'ethers';
+import { TxDataBuilder } from '../TxDataBuilder'
+export class SigFileTransport {
+
+    async create (path: string, txBuilder: TxDataBuilder, params: { wait: boolean }): Promise<{ path: string, signed?: string }> {
+        let tx = $txData.getJson(txBuilder.data, txBuilder.client);
+        let json = {
+            account: {
+                address: txBuilder.account?.address
+            },
+            tx,
+            config: txBuilder.config,
+            raw: utils.serializeTransaction(<any> tx),
+            signature: null,
+        };
+
+        await File.writeAsync(path, json);
+
+
+
+        $logger.log('');
+        $logger.log(`Tx data saved to the file "${path}".`);
+        $logger.log(`Sign the data, insert the signature to the "signature" field and save the file.`);
+        if (params.wait) {
+            $logger.log(`Waiting for the signature...`);
+            $logger.log(`... or you can close this process, and continue later with "0xweb tx send ${path}"`);
+        } else {
+            $logger.log(`Continue later with "0xweb tx send ${path}"`);
+            return { path };
+        }
+        $logger.log('');
+
+        return new Promise((resolve) => {
+            File.watch(path, async () => {
+                $logger.log(`File changed. Checking signature...`);
+                let json = await File.readAsync<{ signature }>(path, { cached: false });
+                if (json?.signature == null) {
+                    $logger.log(`Signature not found. Still waiting...`);
+                    return;
+                }
+                let signed = await $sign.serializeTx(tx, json.signature);
+                resolve({ path, signed });
+            });
+        });
+    }
+
+}

package/src/utils/$abiParser.spec.ts

@@ -0,0 +1,90 @@
+import alot from 'alot';
+import { $abiParser } from './$abiParser'
+
+UTest({
+    'should parse type'() {
+        ([
+            [
+                ['uint256', '(uint256)'],
+                [
+                    {
+                        name: '',
+                        type: 'uint256',
+                    }
+                ]
+            ],
+            [
+                ['(uint256 foo, uint256 bar)'],
+                [
+                    {
+                        name: 'foo',
+                        type: 'uint256'
+                    },
+                    {
+                        name: 'bar',
+                        type: 'uint256'
+                    }
+                ]
+            ],
+
+            [
+                [ 'uint256 foo', '(uint256 foo)'],
+                [
+                    {
+                        name: 'foo',
+                        type: 'uint256'
+                    }
+                ]
+            ],
+
+            [
+                ['(uint256 foo, uint256 bar) user'],
+                [
+                    {
+                        name: 'user',
+                        type: 'tuple',
+                        components: [
+                            {
+                                name: 'foo',
+                                type: 'uint256'
+                            },
+                            {
+                                name: 'bar',
+                                type: 'uint256'
+                            }
+                        ]
+                    }
+                ]
+            ],
+            [
+                ['((uint256 foo, uint256 bar) user, uint256 qux)'],
+                [
+                    {
+                        name: 'user',
+                        type: 'tuple',
+                        components: [
+                            {
+                                name: 'foo',
+                                type: 'uint256'
+                            },
+                            {
+                                name: 'bar',
+                                type: 'uint256'
+                            }
+                        ]
+                    },
+                    {
+                        name: 'qux',
+                        type: 'uint256'
+                    }
+                ]
+            ]
+        ]).forEach(([types, expect]) => {
+            types.forEach(type => {
+                let inputs = $abiParser.parseArguments(type);
+                deepEq_(inputs, expect);
+            });
+        })
+
+    }
+})

package/src/utils/$abiParser.ts

@@ -1,4 +1,4 @@
-import { AbiItem, AbiOutput } from 'web3-utils';
+import type { AbiItem, AbiInput, AbiOutput } from 'web3-utils';
 
 interface IParameter {
     name?: string
@@ -51,7 +51,7 @@ export namespace $abiParser {
         }
 
         let fnName = match.groups.methodName;
-        let $return = match.groups.return?.trim() ?? 'uint256';
+        let $return = match.groups.return?.trim() ?? '';
 
         outputs = parseArguments($return);
 
@@ -74,7 +74,8 @@ export namespace $abiParser {
     // (uint256, uint256)
     // (uint256 foo, uint256 bar)
     // (uint256 foo, uint256 bar)[]
-    export function parseArguments (line: string) {
+    // ((uint256 foo, uint256 bar) foo, uint256 bar)
+    export function parseArguments (line: string): AbiInput[] {
         line = line?.trim();
 
         if (!line || line === '()') {
@@ -90,10 +91,8 @@ export namespace $abiParser {
             let end = Parse.goToClosing(line, 0, c);
             let parametersLine = line.substring(1, end);
             let isArray = line.endsWith('[]');
-
             let params = Parse.parametersLine(parametersLine);
-            let isTuple = params.every(x => Boolean(x.name));
-            if (isTuple && isArray) {
+            if (isArray) {
                 return [
                     {
                         name: '',
@@ -102,18 +101,33 @@ export namespace $abiParser {
                     }
                 ];
             }
-
-            if (params.length === 1) {
-                line = params[0].type;
-
-                params = [
+            let delimiter = line.indexOf(',', end);
+            if (delimiter === -1) {
+                delimiter = line.length;
+            }
+            let tupleName = line.substring(end + 1, delimiter).trim();
+            if (tupleName) {
+                return [
                     {
-                        name: "",
-                        type: line,
-                    },
+                        name: tupleName,
+                        type: `tuple`,
+                        components: params
+                    }
                 ];
             }
 
+
+            // if (params.length === 1) {
+            //     line = params[0].type;
+
+            //     params = [
+            //         {
+            //             name: "",
+            //             type: line,
+            //         },
+            //     ];
+            // }
+
             return params;
         }
 
@@ -129,10 +143,18 @@ export namespace $abiParser {
         //         };
         //     });
         // }
+
+        let name = '';
+        let type = line;
+        let match = /^(?<type>.+)\s+(?<name>[\w_$]+)$/.exec(line);
+        if (match) {
+            name = match.groups.name;
+            type = match.groups.type;
+        }
         return [
             {
-                name: '',
-                type: line,
+                name,
+                type,
             },
         ];
     }
@@ -141,19 +163,32 @@ export namespace $abiParser {
 namespace Parse {
     // uint256 foo, uint bar, address qux
     export function parametersLine (paramsStr: string) {
-        return paramsStr
-            .split(',')
-            .map(x => x.trim())
-            .filter(Boolean)
+        return splitByDelimiter(paramsStr, ',')
             .map(param => {
-                let [_type, _name] = param.split(/\s+/).map(x => x.trim()).filter(Boolean);
-                return {
-                    name: _name ?? '',
-                    type: _type.trim()
-                };
+                let params = $abiParser.parseArguments(param);
+                return params[0];
             });
     }
 
+    export function splitByDelimiter (line: string, delimiter: string) {
+        let parts = [];
+        let start = 0;
+        for (let i = 0; i < line.length; i++) {
+            let c = line[i];
+            if (c === delimiter) {
+                parts.push(line.substring(start, i).trim());
+                start = i + 1;
+                continue;
+            }
+            if (c === '(') {
+                i = goToClosing(line, i, c);
+                continue;
+            }
+        }
+        // final part
+        parts.push(line.substring(start).trim());
+        return parts.filter(Boolean);
+    }
 
     export function goToClosing (str: string, startI: number, openChar: string, closeChar?: string) {
         closeChar = closeChar ?? CLOSE_CHARS[openChar];

package/src/utils/$abiType.ts

@@ -1,8 +1,99 @@
 import alot from 'alot';
-
+import { type AbiInput } from 'web3-utils';
+import { $require } from './$require';
 export namespace $abiType {
 
-    export function getTsType ($abiType: string, $abi?: { type, name, components? }) {
+    export function getTsTypeFromDefinition (type: string) {
+        type = type.trim();
+
+        let rgxArray = /\[(?<size>\d+)?\]$/;
+        let isArray = rgxArray.test(type);
+        if (isArray) {
+            let baseType = array.getBaseType(type);
+            let baseTsType = getTsTypeFromDefinition(baseType);
+            let match = rgxArray.exec(type);
+            return `${baseTsType}${match[0]}`;
+        }
+
+        if (type.startsWith('(')) {
+            let entries = [] as { ts: string, name: string }[];
+            for (let i = 1; i < type.length; i++) {
+                i = Parse.skipWhitespace(type, i);
+
+                let c = type[i];
+
+                let start = i;
+                let tsTypeEnd: number;
+                if (c === '(') {
+                    i = 1 + Parse.goToClosing(type, i + 1, c);
+                    tsTypeEnd = i;
+                } else if (c === 'm' && type.substring(i, i + 'mapping'.length) === 'mapping') {
+                    i = i + 'mapping'.length;
+                    i = Parse.skipWhitespace(type, i);
+                    let c = type[i];
+                    if (c !== '(') {
+                        throw new Error(`Expect "(" after the mapping keyword. Got ${type.substring(i, i + 10)} ...`);
+                    }
+                    i = 1 + Parse.goToClosing(type, i + 1, c);
+                    tsTypeEnd = i;
+                } else {
+                    i = Parse.goToTypeBoundary(type, i);
+                    tsTypeEnd = i;
+                }
+
+                i = Parse.skipWhitespace(type, i);
+                c = type[i];
+                if (c === '[') {
+                    i = 1 + Parse.goToClosing(type, i + 1, c);
+                    tsTypeEnd = i;
+                }
+
+                let solType = type.substring(start, i);
+                let tsType = getTsTypeFromDefinition(solType)
+                let name: string = null;
+
+                i = Parse.skipWhitespace(type, i);
+                c = type[i];
+                if (/[\w_$]/.test(c)) {
+                    start = i;
+                    i = Parse.goToTypeBoundary(type, i);
+                    name = type.substring(start, i);
+                }
+                entries.push({ ts: tsType, name: name });
+
+                i = Parse.skipWhitespace(type, i);
+                c = type[i];
+                if (c === ')') {
+                    break;
+                }
+                if (c === ',') {
+                    i++;
+                    continue;
+                }
+                console.log(`Invalid character starting at: ${type.substring(i)}`);
+            }
+
+            let isArray = entries.every(x => x.name == null);
+            if (isArray) {
+                return `[ ${entries.map(x => x.ts).join(', ')} ]`
+            }
+            let keys = entries.map(x => `${x.name}: ${x.ts}`).join(', ');
+
+            return `{ ${keys} }`;
+        }
+
+        if (type.startsWith('mapping')) {
+            let valueType = $abiType.mapping.getValueType(type);
+            let keyType = $abiType.mapping.getKeyType(type);
+
+            let keyTsType = getTsTypeFromDefinition(keyType);
+            let valueTsType = getTsTypeFromDefinition(valueType);
+
+            return `Record<${keyTsType}, ${valueTsType}>`;
+        }
+        return getTsType(type);
+    }
+    export function getTsType ($abiType: AbiInput['type'], $abi?: { type, name, components? }) {
         let rgxArray = /\[(?<size>\d+)?\]$/
         let isArray = rgxArray.test($abiType);
 
@@ -37,17 +128,61 @@ export namespace $abiType {
         }
 
         if (tsType == null) {
-            throw new Error(`Unknown abi type in return: ${abiType}`);
+            throw new Error(`Unknown abi type in return: "${abiType}"`);
         }
 
         return isArray
             ? `${tsType}[]`
             : `${tsType}`;
+    };
+
+    export namespace array {
+        // uint256[2] bytes32[] ...
+        export function getBaseType (arrayType: string) {
+            let baseType = arrayType.replace(/\[\d*\]\s*$/, '');
+            $require.notEq(baseType, arrayType, `${arrayType} is not valid array declaration`);
+            return baseType;
+        }
+        export function getLength (arrayType: string) {
+            let match = /\[(?<len>\d+)?\]$/.exec(arrayType);
+            $require.notNull(match, `${arrayType} is not valid array declaration`);
+
+            return Number(match.groups.len ?? Infinity);
+        }
+    }
+    export namespace mapping {
+        export function getKeyType (mappingType: string) {
+            let mid = mappingType.indexOf('=>');
+            $require.True(mid > -1, `Invalid mapping type: ${mappingType}`);
+            let str = mappingType.substring(0, mid);
+            return str.replace(/mapping\s*\(/, '').trim();
+        }
+        export function getValueType (mappingType: string) {
+            let mid = mappingType.indexOf('=>');
+            $require.True(mid > -1, `Invalid mapping type: ${mappingType}`);
+
+            let closed = 0;
+            for (let i = mid + 2; i < mappingType.length; i++) {
+                let c = mappingType[i];
+                if (c === '(') {
+                    closed++;
+                    continue;
+                }
+                if (c === ')') {
+                    closed -= 1;
+                    if (closed === -1) {
+                        return mappingType.substring(mid + 2, i).trim();
+                    }
+                }
+            }
+            throw new Error(`Mapping value was not extracted from ${mappingType}`);
+        }
     }
 
 
 
     const AbiTsTypes = {
+        'enum': 'number',
         'uint': 'number',
         'int': 'number',
 
@@ -66,9 +201,9 @@ export namespace $abiType {
     const AbiTsTypesRgx = [
 
         {
-            rgx: /u?int(?<bits>\d+)/,
+            rgx: /u?int(?<bits>\d+)?/,
             fromMatch (match: RegExpMatchArray) {
-                let bits = Number(match.groups.bits);
+                let bits = Number(match.groups.bits ?? 256);
                 if (bits > 64) {
                     return 'bigint';
                 }
@@ -76,6 +211,13 @@ export namespace $abiType {
             },
             type: null,
         },
+        {
+            rgx: /bytes(?<bits>\d+)?/,
+            fromMatch (match: RegExpMatchArray) {
+                return 'TBufferLike';
+            },
+            type: null,
+        },
 
         // {
         //     rgx: /uint\d+/,
@@ -83,3 +225,51 @@ export namespace $abiType {
         // }
     ];
 }
+
+
+namespace Parse {
+
+    export function skipWhitespace (str: string, _i: number) {
+        let i = _i;
+        for (; i < str.length; i++) {
+            if (str.charCodeAt(i) > 32) {
+                return i;
+            }
+        }
+        return i;
+    }
+
+
+    export function goToClosing (str: string, startI: number, openChar: string, closeChar?: string) {
+        closeChar = closeChar ?? CLOSE_CHARS[openChar];
+        let count = 1;
+        for (let i = startI; i < str.length; i++) {
+            if (str[i] === openChar) {
+                count++;
+            }
+            if (str[i] === closeChar) {
+                count--;
+            }
+            if (count === 0) {
+                return i;
+            }
+        }
+        throw new Error(`Unmatched closing chars ${openChar} ${closeChar} in ${str}`);
+    }
+
+    const CLOSE_CHARS = {
+        '[': ']',
+        '(': ')'
+    };
+
+    export function goToTypeBoundary(type: string, i: number): number {
+        let rgx = /[\w_$]/;
+        for (; i < type.length; i++) {
+            if (rgx.test(type[i])) {
+                continue;
+            }
+            break;
+        }
+        return i;
+    }
+}

package/src/utils/$abiUtils.ts

@@ -1,7 +1,8 @@
-import { AbiItem } from 'web3-utils';
-import { AbiCoder }  from '@ethersproject/abi';
-import { $contract } from './$contract';
+import { type AbiItem } from 'web3-utils';
 import Web3 from 'web3';
+import { utils }  from 'ethers';
+import { $contract } from './$contract';
+import { $abiParser } from './$abiParser';
 
 export namespace $abiUtils {
 
@@ -10,24 +11,74 @@ export namespace $abiUtils {
     }
 
     export function encode (types: any[], values: any[]) {
-        let coder = new AbiCoder();
+        let coder = new utils.AbiCoder();
         return coder.encode(types, values)
     }
 
     /** Returns complete method/event hash */
-    export function getMethodHash (abi: AbiItem) {
+    export function getMethodHash (mix: string | AbiItem) {
+        let abi = typeof mix === 'string'
+            ? $abiParser.parseMethod(mix)
+            : mix;
         let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
         let signature = `${abi.name}(${types.join(',')})`;
         let hash = $contract.keccak256(signature);
         return hash;
     }
 
-    export function getMethodSignature (abi: AbiItem) {
+    export function getMethodSignature (mix: string | AbiItem) {
+        let abi = typeof mix === 'string'
+            ? $abiParser.parseMethod(mix)
+            : mix;
         let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
         let signature = `${abi.name}(${types.join(',')})`;
         let hash = $contract.keccak256(signature);
         return hash.substring(0, 10);
     }
+
+    export function getTopicSignature (abi: AbiItem) {
+        let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
+        let signature = `${abi.name}(${types.join(',')})`;
+        let hash = $contract.keccak256(signature);
+        return hash;
+    }
+
+    export function checkInterfaceOf (abi: AbiItem[], iface: AbiItem[]): { ok: boolean, missing?: string } {
+        if (iface == null || iface.length === 0) {
+            return { ok: false };
+        }
+        for (let item of iface) {
+            if (item.type === 'constructor') {
+                continue;
+            }
+            let inAbi = abi.some(x => abiEquals(x, item));
+            if (inAbi === false) {
+                return { ok: false, missing: item.name };
+            }
+        }
+        return { ok: true };
+    }
+
+    function abiEquals (a: AbiItem, b: AbiItem) {
+        if (a.name !== b.name) {
+            return false;
+        }
+        let aInputs = a.inputs ?? [];
+        let bInputs = b.inputs ?? [];
+        if (aInputs.length !== bInputs.length) {
+            return false;
+        }
+        //@TODO: may be better AbiInput comparison?
+        for (let i = 0; i < aInputs.length; i++) {
+            let aInput = aInputs[i];
+            let bInput = bInputs[i];
+            if (aInput?.type !== bInput?.type) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     function serializeMethodSignatureArgumentType (input: AbiItem['inputs'][0]) {
         if (input.type === 'tuple') {
             let types = input.components.map(x => serializeMethodSignatureArgumentType(x));

package/src/utils/$account.ts

@@ -0,0 +1,30 @@
+import { ChainAccount, SafeAccount, TAccount } from "@dequanto/models/TAccount";
+import { $address } from './$address';
+
+export namespace $account {
+
+    export function getSender (account: TAccount): ChainAccount {
+        if (typeof account === 'string') {
+            if ($address.isValid(account)) {
+                return { address: account };
+            }
+            return { name: account };
+        }
+
+        let acc = isSafe(account)
+            ? account.operator
+            : account;
+
+        return acc;
+    }
+
+    export function isSafe (account:TAccount): account is SafeAccount {
+        if (account == null) {
+            return false;
+        }
+        if (typeof account === 'string') {
+            return /^safe\//.test(account);
+        }
+        return 'operator' in account;
+    }
+}

package/src/utils/$address.ts

@@ -1,4 +1,5 @@
 import { TAddress } from '@dequanto/models/TAddress';
+import web3 from 'web3';
 
 export namespace $address {
     export function eq (a1: string, a2: string) {
@@ -33,5 +34,9 @@ export namespace $address {
         return address.toLowerCase().substring(2).padStart(32, '0');
     }
 
+    export function toChecksum (address: TAddress) {
+        return web3.utils.toChecksumAddress(address);
+    }
+
     export const ZERO = '0x0000000000000000000000000000000000000000'
 }