dequanto 0.2.46 → 0.2.48

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/clients/model/ClientStatus.ts

@@ -2,5 +2,6 @@ export enum ClientStatus {
     Ok = 200,
     NetworkError = 500,
     RateLimited = 501,
+    NodeConfigurationError = 502,
     CallError = 400
 }

package/src/clients/utils/ClientErrorUtil.ts

@@ -14,6 +14,14 @@ export namespace ClientErrorUtil {
         }
         return false;
     }
+    export function isNodeConfigurationError (error: Error & { code?, reason? }) {
+        let str = error.message ?? error.stack;
+        let noHistory = /history unavailable/i.test(str);
+        if (noHistory) {
+            return true;
+        }
+        return false;
+    }
     export function isAlreadyKnown (error: Error & { code?, reason? }) {
         return /already known/i.test(error.message);
     }

package/src/config/ConfigDefaults.ts

@@ -116,9 +116,6 @@ export const ConfigDefaults = <IConfigData> {
             "chainId": 1,
             "chainToken": "ETH",
             "endpoints": [
-                {
-                    "url": "https://ethereum-rpc.publicnode.com"
-                },
                 {
                     "url": "https://eth.drpc.org",
                     "rateLimit": "2000/5m"

package/src/contracts/ContractCreationResolver.ts

@@ -72,6 +72,7 @@ class BlockchainExplorerDateResolver {
             throw error;
         }
         let tx = await this.client.getTransaction(info.txHash);
+        $require.notNull(tx, `Tx not found: ${info.txHash} in ${this.client.network} (${this.client.options?.endpoints?.[0]?.url})`);
         let block = await this.client.getBlock(tx.blockNumber);
         return {
             tx: tx.hash,

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/rpc/RpcBase.ts

@@ -122,7 +122,7 @@ export abstract class RpcBase {
         };
     }
     private _unwrapBody (resp: any): any {
-        return resp.result;
+        return RpcBase.unwrapBody(resp);
     }
     private _deserialize (method: string, result: any) {
         let { methods, schemas } = this.returnSchemas;
@@ -141,6 +141,10 @@ export abstract class RpcBase {
 
 
     protected abstract returnSchemas
+
+    static unwrapBody (resp: any) {
+        return resp.result;
+    }
 }
 
 

package/src/solidity/utils/$str.ts

@@ -44,7 +44,7 @@ export namespace $str {
     }
 
     export function fromHex(hex: TEth.Hex) {
-        let trimmed = $hex.trimBytes(hex);
+        let trimmed = $hex.trimBytesEnd(hex);
         return $buffer.fromHex(trimmed).toString();
     }
 

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/$base.ts

@@ -18,7 +18,7 @@ export namespace $base {
 
         public encode (hex: TEth.Hex): string {
             hex = $hex.toHexBuffer(hex);
-            hex = $hex.trimBytes(hex);
+            hex = $hex.trimBytesStart(hex);
             let buffer = $buffer.fromHex(hex);
 
             let result = [];

package/src/utils/$crypto.ts

@@ -8,6 +8,7 @@ interface ICrypto {
     randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
     createECDH(curve: string)
 
+    sha256 (mix: string | TEth.Hex | Uint8Array, opts?: { encoding: 'hex' }): Promise<TEth.Hex>;
     sha256 (mix: string | TEth.Hex | Uint8Array): Promise<Uint8Array>;
 
     encrypt(buffer: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & { encoding?: undefined | 'binary' }): Promise<Uint8Array>

package/src/utils/$hex.ts

@@ -24,10 +24,19 @@ export namespace $hex {
      * Trims '00' bytes from start or end, e.g.  0x68656c6c6f000000 =>  0x68656c6c6f
      */
     export function trimBytes(hex: TEth.Hex): TEth.Hex {
-        if (hex.startsWith('0x00') === false && hex.endsWith('00') === false) {
+        return trimBytesEnd(trimBytesStart(hex));
+    }
+    export function trimBytesStart(hex: TEth.Hex): TEth.Hex {
+        if (hex.startsWith('0x00') === false) {
             return hex;
         }
-        return hex.replace(/^0x(0{2})+/, '0x').replace(/(0{2})+$/, '') as TEth.Hex;
+        return hex.replace(/^0x(0{2})+/, '0x') as TEth.Hex;
+    }
+    export function trimBytesEnd(hex: TEth.Hex): TEth.Hex {
+        if (hex.endsWith('00') === false) {
+            return hex;
+        }
+        return hex.replace(/(0{2})+$/, '') as TEth.Hex;
     }
     export function trimLeadingZerosFromNumber(hex: string) {
         hex = hex.replace(/^0x0*/, '');
@@ -114,7 +123,6 @@ export namespace $hex {
         return hex;
     }
 
-
     /**
      * Adds `0x` to the start if not present
      */
@@ -131,6 +139,7 @@ export namespace $hex {
         if (typeof mix ==='boolean') {
             return mix ? '0x1' : '0x0';
         }
+        $require.match(/^(0x)?[\da-f]*$/i, mix, 'NotValidHex');
         if (mix.startsWith('0x')) {
             return mix as TEth.Hex;
         }