dequanto 0.2.47 → 0.2.49

package/src/clients/Web3ClientFactory.ts

@@ -6,16 +6,19 @@ import { Config } from '@dequanto/config/Config';
 import { EvmWeb3Client } from './EvmWeb3Client';
 import { $require } from '@dequanto/utils/$require';
 import { $config } from '@dequanto/utils/$config';
+import type { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client';
 
 export namespace Web3ClientFactory {
 
-    export function get (platform: TPlatform | number, opts?: IWeb3EndpointOptions) {
+    export function get <
+        TClient extends EvmWeb3Client | HardhatWeb3Client = EvmWeb3Client
+    > (platform: TPlatform | number, opts?: IWeb3EndpointOptions): TClient {
         if (typeof platform === 'string' && (platform === 'hardhat' || platform.startsWith('hh:'))) {
             let client = di.resolve(HardhatProvider).client('localhost', opts);
             if (platform.startsWith('hh:')) {
                 client.configureFork(platform.slice(3));
             }
-            return client;
+            return client as TClient;
         }
 
         let options = $config.getWeb3Options(platform);
@@ -23,12 +26,14 @@ export namespace Web3ClientFactory {
         return new EvmWeb3Client({
             ...options,
             ...(opts ?? {})
-        });
+        }) as TClient;
     }
 
     /** Same as the sync variant, but ensures the config is fetched */
-    export async function getAsync (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions) {
+    export async function getAsync <
+        TClient extends EvmWeb3Client | HardhatWeb3Client = EvmWeb3Client
+    > (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions): Promise<TClient> {
         let cfg = await Config.get();
-        return get(platform, opts);
+        return get<TClient>(platform, opts);
     }
 }

package/src/contracts/wrappers/FnRequestWrapper.ts

@@ -9,7 +9,7 @@ export namespace FnRequestWrapper {
 
 type TRequests<T extends ContractBase> = {
     [K in keyof T]: T[K] extends (...any) => Promise<any>
-        ? (...params: Parameters<T[K]>) => ContractReaderUtils.IContractReadParams<Awaited<ReturnType<T[K]>>>
+        ? (...params: Parameters<T[K]>) => Promise<ContractReaderUtils.IContractReadParams<Awaited<ReturnType<T[K]>>>>
         : never
 }
 

package/src/models/TAccount.ts

@@ -65,7 +65,7 @@ export interface TimelockAccount extends IAccount {
     // Erc4337 account must include platform information
     platform: TPlatform
 
-    operator: EoAccount
+    operator: IAccount
 }
 
 export type TAccount = string | IAccount | EoAccount | SafeAccount | Erc4337Account;

package/src/utils/$abiParser.ts

@@ -86,6 +86,69 @@ export namespace $abiParser {
         };
     }
 
+
+    /**
+     * Parses Solidity struct declarations into a tuple ABI component.
+     * Supports multiple declarations so later structs can reference earlier ones,
+     * and returns the ABI component for the last struct in the input.
+     */
+    export function parseStruct (struct: string): TAbiItem {
+        let structs = Parse.structs(struct);
+        $require.gt(structs.length, 0, `No structs found in ${struct}`);
+
+        let byName = new Map(structs.map(x => [ x.name, x ]));
+        let cache = new Map<string, TAbiInput>();
+
+        function toTuple (name: string): TAbiInput {
+            let cached = cache.get(name);
+            if (cached != null) {
+                return cached;
+            }
+            let def = byName.get(name);
+            $require.notNull(def, `Struct ${name} is not found`);
+
+            let tuple: TAbiInput = {
+                name: '',
+                type: 'tuple',
+                internalType: `struct ${name}`,
+                components: []
+            };
+            cache.set(name, tuple);
+            tuple.components = Parse.splitByDelimiter(def.body, ';')
+                .map(field => $abiParser.parseArguments(field)[0])
+                .map(resolveStructs);
+
+            return tuple;
+        }
+
+        function resolveStructs (param: TAbiInput): TAbiInput {
+            let { type, array } = Parse.extractArray(param.type);
+            if (byName.has(type) === false) {
+                if (param.components != null) {
+                    return {
+                        ...param,
+                        components: param.components.map(resolveStructs)
+                    };
+                }
+                return param;
+            }
+
+            let tuple = toTuple(type);
+            return {
+                name: param.name,
+                type: `tuple${array}`,
+                internalType: `struct ${type}${array}`,
+                components: tuple.components
+            };
+        }
+
+        let last = structs[structs.length - 1];
+        return {
+            ...toTuple(last.name),
+            name: last.name
+        } as any as TAbiItem;
+    }
+
     // uint256
     // address[]
     // (uint256, uint256)
@@ -247,6 +310,35 @@ namespace Parse {
 
     const CLOSE_CHARS = {
         '[': ']',
-        '(': ')'
+        '(': ')',
+        '{': '}'
     };
+
+    export function structs (source: string) {
+        let rgx = /\bstruct\s+(?<name>[\w_$]+)\s*\{/g;
+        let arr: { name: string, body: string }[] = [];
+        let match: RegExpExecArray;
+        while ((match = rgx.exec(source)) != null) {
+            let openI = source.indexOf('{', match.index);
+            let closeI = goToClosing(source, openI, '{');
+            arr.push({
+                name: match.groups.name,
+                body: source.substring(openI + 1, closeI).trim()
+            });
+            rgx.lastIndex = closeI + 1;
+        }
+        return arr;
+    }
+
+    export function extractArray (type: string) {
+        let array = '';
+        while (true) {
+            let match = /^(?<type>.+?)(?<array>\[[^\]]*\])$/.exec(type);
+            if (match == null) {
+                return { type, array };
+            }
+            type = match.groups.type;
+            array = `${match.groups.array}${array}`;
+        }
+    }
 }

package/src/utils/$hex.ts

@@ -3,7 +3,9 @@ import { $buffer } from './$buffer';
 import { $require } from './$require';
 export namespace $hex {
 
-    export const ZERO = '0x'
+    export const ZERO = '0x';
+
+    export const ZERO_Bytes32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
 
     /**
      * Adds '00' bytes to the hex string

package/src/utils/$require.ts

@@ -200,6 +200,7 @@ export namespace $require {
         if (a <= b) {
             throw new Error(`Expected a(${a}) > b(${b}). ${message}`);
         }
+        return a;
     }
     export function gte<T = number | bigint> (a: T, b: T, message: string = '') {
         Numeric(a);
@@ -207,6 +208,7 @@ export namespace $require {
         if (a < b) {
             throw new Error(`Expected a(${a}) > b(${b}). ${message}`);
         }
+        return a;
     }
 
     /**
@@ -218,6 +220,7 @@ export namespace $require {
         if (a >= b) {
             throw new Error(`Expected a(${a}) > b(${b}). ${message}`);
         }
+        return a;
     }
     export function lte<T = number | bigint> (a: T, b: T, message: string = '') {
         Numeric(a);
@@ -225,5 +228,6 @@ export namespace $require {
         if (a > b) {
             throw new Error(`Expected a(${a}) > b(${b}). ${message}`);
         }
+        return a;
     }
 }