dequanto 0.2.47 → 0.2.48

package/src/abi/$abiCoder.ts

@@ -6,11 +6,24 @@ import { TEth } from '@dequanto/models/TEth';
 import { $abiParser } from '@dequanto/utils/$abiParser';
 
 export namespace $abiCoder {
-    export function encode(types: (string | ParamType | TAbiInput)[], values: any[]): TEth.Hex {
+
+    type TAbiType = string | ParamType | TAbiInput;
+    type TDecodeOptions = {
+        loose?: boolean
+        dynamic?: boolean
+    };
+
+    export function encode(types: TAbiType, values: any): TEth.Hex
+    export function encode(types: TAbiType[], values: any[]): TEth.Hex
+    export function encode(types: TAbiType | TAbiType[], values: any | any[]): TEth.Hex {
+        if (Array.isArray(types) == false) {
+            return encodeSingle(types, values)
+        }
         let coder = new AbiCoder();
         return coder.encode(types, values) as TEth.Hex;
     }
-    export function encodeSingle(type: (string | ParamType | TAbiInput), value: any): TEth.Hex {
+    export function encodeSingle(type: TAbiType, value: any): TEth.Hex {
+        type = normalizeType(type);
         let coder = new AbiCoder();
         return coder.encodeSingle(type, value) as TEth.Hex;
     }
@@ -19,20 +32,20 @@ export namespace $abiCoder {
         return solidityPacked(types, values) as TEth.Hex;
     }
 
-    export function decode(types: (string | ParamType | TAbiInput)[], hex: string, opts?: {
-        loose?: boolean
-        dynamic?: boolean
-    }): any {
+    export function decode(types: TAbiType, hex: string, opts?: TDecodeOptions): any
+    export function decode(types: TAbiType[], hex: string, opts?: TDecodeOptions): any[]
+    export function decode(types: TAbiType| TAbiType[], hex: string, opts?: TDecodeOptions): any {
+        if (Array.isArray(types) == false) {
+            return decodeSingle(types, hex, opts)
+        }
         let coder = new AbiCoder();
         let arr = coder.decode(types, hex, opts);
         return arr.map((x, i) => {
             return unwrap(types[i] as TAbiInput, x);
         });
     }
-    export function decodeSingle(type: (string | ParamType | TAbiInput), hex: string, opts?: {
-        loose?: boolean
-        dynamic?: boolean
-    }): any {
+    export function decodeSingle(type: TAbiType, hex: string, opts?: TDecodeOptions): any {
+        type = normalizeType(type);
         let coder = new AbiCoder();
         let x = coder.decodeSingle(type, hex, opts);
         return unwrap(type as TAbiInput, x);
@@ -72,4 +85,12 @@ export namespace $abiCoder {
         }
         return mixValue;
     }
+
+
+    function normalizeType (type: TAbiType) {
+        if (typeof type === 'string' && /\bstruct /.test(type)) {
+            return $abiParser.parseStruct(type);
+        }
+        return type;
+    }
 }

package/src/clients/Web3Client.ts

@@ -97,6 +97,8 @@ export abstract class Web3Client implements IWeb3Client {
         });
     }
 
+    // Low-level batch for raw RPC calls.
+    // For contract batch calls, use batchContractCalls to decode the responses.
     async batch(requests: TRpc.IRpcAction[], options?: {
         allowErrors?: boolean
     }): Promise<any[]> {
@@ -105,6 +107,15 @@ export abstract class Web3Client implements IWeb3Client {
         });
     }
 
+    // Submit contract calls in a batch and decode the responses.
+    async batchContractCalls(requests: TRpcContractCall[], options?: {
+        allowErrors?: boolean
+    }) {
+        let reader = new RpcContract(this);
+        let result = await reader.batch(requests, options);
+        return result;
+    }
+
     getEventStream(address: TEth.Address, abi: TAbiItem[], event: string) {
         let eventAbi = abi.find(x => x.type === 'event' && x.name === event);
         if (eventAbi == null) {
@@ -189,12 +200,11 @@ export abstract class Web3Client implements IWeb3Client {
         return result;
     }
 
+    // Alias for batchContractCalls.
     async readContractBatch(requests: TRpcContractCall[], options?: {
         allowErrors?: boolean
     }) {
-        let reader = new RpcContract(this);
-        let result = await reader.batch(requests, options);
-        return result;
+        return this.batchContractCalls(requests, options);
     }
 
 
@@ -412,12 +422,12 @@ export abstract class Web3Client implements IWeb3Client {
     //     return tx;
     // }
 
-    async sign(address: TEth.Address, message: string): Promise<string> {
+    async sign(address: TEth.Address, message: string): Promise<TEth.Hex> {
         if (this.wallet.isConnected(address)) {
-            return this.wallet.eth_sign(address, message);
+            return this.wallet.eth_sign(address, message) as Promise<TEth.Hex>;
         }
         return this.pool.call(wClient => {
-            return wClient.sign(address, message);
+            return wClient.sign(address, message) as Promise<TEth.Hex>;
         }, {
             wallet: true
         });

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}`;
+        }
+    }
 }