dequanto 0.2.48 → 0.2.50

package/src/clients/Web3ClientFactory.ts

@@ -7,6 +7,7 @@ import { EvmWeb3Client } from './EvmWeb3Client';
 import { $require } from '@dequanto/utils/$require';
 import { $config } from '@dequanto/utils/$config';
 import type { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client';
+import { IConfigData } from '@dequanto/config/interface/IConfigData';
 
 export namespace Web3ClientFactory {
 
@@ -14,9 +15,23 @@ export namespace Web3ClientFactory {
         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));
+            // hardhat       - local hardhat network
+            // hh:eth        - local hardhat network (which runs as a fork)
+            // hh:memory     - in-memory hardhat network
+            // hh:memory:eth - getAsync only: in-memory forked hardhat network
+            if (platform.startsWith('hh:memory:')) {
+                throw new Error(`use getAsync to resolve forked "${platform}" client`);
+            }
+
+            let network = platform.startsWith('hh:')
+                ? platform.slice(3)
+                : null;
+            let hh = network === 'memory'
+                ? 'hardhat' as const
+                : 'localhost' as const;
+            let client = di.resolve(HardhatProvider).client(hh, opts);
+            if (network != null && network !== 'memory') {
+                client.configureFork(network);
             }
             return client as TClient;
         }
@@ -29,11 +44,24 @@ export namespace Web3ClientFactory {
         }) as TClient;
     }
 
+    type HHInMemoryForkData = {
+        block?: number
+        url?: string
+    }
     /** Same as the sync variant, but ensures the config is fetched */
     export async function getAsync <
         TClient extends EvmWeb3Client | HardhatWeb3Client = EvmWeb3Client
-    > (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions): Promise<TClient> {
-        let cfg = await Config.get();
+    > (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions & HHInMemoryForkData & { config?: Partial<IConfigData>}): Promise<TClient> {
+        let cfg = await Config.get(opts?.config);
+        if (typeof platform === 'string' && platform.startsWith('hh:memory:')) {
+            let network = platform.replace('hh:memory:', '');
+            let client = await di.resolve(HardhatProvider).forked({
+                platform: network,
+                block: opts?.block,
+                url: opts?.url,
+            });
+            return client as TClient;
+        }
         return get<TClient>(platform, opts);
     }
 }

package/src/clients/debug/ClientDebugMethods.ts

@@ -7,6 +7,7 @@ import { $hex } from '@dequanto/utils/$hex';
 import { TEth } from '@dequanto/models/TEth';
 import { $array } from '@dequanto/utils/$array';
 import { $date } from '@dequanto/utils/$date';
+import { $number } from '@dequanto/utils/$number';
 
 
 export class ClientDebugMethods {
@@ -53,10 +54,13 @@ export class ClientDebugMethods {
         return this.call('mine', ...args);
     }
 
-    setBalance (address: TAddress, amount: bigint | string) {
+    setBalance (address: TAddress, amount: bigint | number | string) {
         if (typeof amount === 'bigint') {
             amount = $bigint.toHex(amount);
         }
+        if (typeof amount === 'number') {
+            amount = $number.toHex(amount);
+        }
         return this.call('setBalance', address, amount);
     }
 

package/src/clients/utils/$web3Abi.ts

@@ -8,13 +8,13 @@ export namespace $web3Abi {
         let arr: TAbiItem[];
         if (typeof abi === 'string') {
             arr = [ $abiParser.parseMethod(abi) ];
-        } else  if (Array.isArray(abi)) {
+        } else if (Array.isArray(abi)) {
             arr = abi;
         } else {
             arr = [ abi ];
         }
 
-        let first = abi[0];
+        let first = arr[0];
         if (first.outputs == null || first.outputs.length === 0) {
             // Normalize outputs to read at least bytes if nothing is set
             first.outputs = [

package/src/config/AConfigBase.ts

@@ -5,6 +5,10 @@ import { TEth } from '@dequanto/models/TEth'
 
 type TConfigParamsBase = {
     config?: Partial<IConfigData>
+    // alias for config.web3.platform.endpoints
+    rpc?: {
+        [platform: string]: string | string[] | IConfigData['web3']['']['endpoints']
+    }
 }
 
 export type TConfigParamsNode = TConfigParamsBase & {

package/src/config/Config.ts

@@ -12,6 +12,27 @@ export class Config {
     static async fetch (parameters?: TConfigParamsNode | TConfigParamsBrowser): Promise<Appcfg<IConfigData> & IConfigData> {
         singleton ??= new class_Dfr();
 
+        if (parameters?.rpc) {
+            parameters.config ??= {};
+            parameters.config.web3 ??= {};
+            for (let platform in parameters.rpc) {
+                parameters.config.web3[platform] ??= {} as any;
+                parameters.config.web3[platform].endpoints = [];
+                let val = parameters.rpc[platform];
+                if (typeof val === 'string') {
+                    parameters.config.web3[platform].endpoints.push({
+                        url: val
+                    });
+                    continue;
+                }
+                if (Array.isArray(val) && typeof val[0] === 'string') {
+                    parameters.config.web3[platform].endpoints.push(...val.map(url => ({url})));
+                    continue;
+                }
+                parameters.config.web3[platform].endpoints = val as any;
+            }
+        }
+
         let cfg = await provider.fetch(parameters);
 
         obj_extend(config, cfg);
@@ -28,21 +49,22 @@ export class Config {
     }
 
     /** Will return a config that was previously loaded by fetch with any parameters or will trigger fetch with default parameters  */
-    static async get (): Promise<Appcfg<IConfigData> & IConfigData>  {
-        if (singleton != null) {
+    static async get (config?: Partial<IConfigData>): Promise<Appcfg<IConfigData> & IConfigData>  {
+        if (singleton != null && config == null) {
             return singleton;
         }
-        return Config.fetch();
+        return Config.fetch({ config });
     }
 
-    // static async getExplorerConfig (platform: TPlatform | number): Promise<TExplorer> {
-    //     let config = await Config.get();
-
-    // }
-
     static async extend (json) {
         await provider.extend(json);
     }
+
+    static clean (): Config {
+        memd.fn.clearMemoized(Config.fetch);
+        singleton = null;
+        return Config;
+    }
 }
 
 export const config = { } as IConfigData;

package/src/config/ConfigDefaults.ts

@@ -1,5 +1,6 @@
 import { IConfigData } from './interface/IConfigData';
-export const ConfigDefaults = <IConfigData> {
+import { DefaultFactory } from './DefaultFactory';
+export const ConfigDefaults = DefaultFactory({
     "accounts": null,
     "settings": {
         "generate": {
@@ -116,6 +117,9 @@ export const ConfigDefaults = <IConfigData> {
             "chainId": 1,
             "chainToken": "ETH",
             "endpoints": [
+                {
+                    "url": "https://ethereum-rpc.publicnode.com"
+                },
                 {
                     "url": "https://eth.drpc.org",
                     "rateLimit": "2000/5m"
@@ -504,4 +508,4 @@ export const ConfigDefaults = <IConfigData> {
         "base": "0x00000000000D6FFc74A8feb35aF5827bf57f6786",
         "linea": "0x00000000000D6FFc74A8feb35aF5827bf57f6786"
     }
-};
+});

package/src/config/ConfigProvider.ts

@@ -33,7 +33,6 @@ export class ConfigProvider implements IConfigProvider {
             ;
 
         let cfg = await AppConfig.fetch<IConfigData>(sources);
-
         if (this.config != null) {
             this.config.$extend(cfg.toJSON());
         } else {
@@ -102,6 +101,11 @@ export class ConfigProvider implements IConfigProvider {
             parameters?.dotenv ? {
                 dotenv: true
             } : null,
+            parameters?.config ? {
+                sync: true,
+                extendArrays: false,
+                config: parameters.config
+            } : null,
         ];
     }
 

package/src/config/DefaultFactory.ts

@@ -0,0 +1,26 @@
+import { IConfigData } from './interface/IConfigData';
+
+export function DefaultFactory (config: IConfigData): IConfigData {
+
+    if (typeof process !== 'undefined' && process.env != null) {
+        for (let key in process.env) {
+            if (key.startsWith('RPC_') === false) {
+                continue;
+            }
+            const platform = key.replace('RPC_', '').toLowerCase();
+            if (platform in config.web3 === false) {
+                continue;
+            }
+
+            const url = process.env[key];
+            if (/^(http|ws)/.test(url) === false) {
+                continue;
+            }
+            config.web3[platform].endpoints = [
+                { url: url }
+            ];
+        }
+    }
+
+    return config;
+}

package/src/config/interface/IConfigData.ts

@@ -4,6 +4,7 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { TPlatform } from '@dequanto/models/TPlatform';
 import { IRpcConfig } from '@dequanto/clients/ClientPool';
 import { TChain } from '@dequanto/models/TChain';
+import { TEth } from '@dequanto/models/TEth';
 
 
 export interface IConfigData {
@@ -28,10 +29,10 @@ export interface IConfigData {
 
     blockchainExplorer: {
         [platform in TPlatform]: {
-            key: string;
+            key?: string;
             host?: string;
             api?: string
-            wwww?: string
+            www?: string
         };
     };
 
@@ -77,4 +78,16 @@ export interface IConfigData {
         [platform in TPlatform]: TAddress
     };
 
+    ns: {
+        [service: string]: {
+            [platform: string]: {
+                registry: TEth.Address
+                resolver?: TEth.Address
+            }
+        }
+    }
+
+    oracles: {
+        [service: string]: any
+    }
 }

package/src/contracts/ContractBase.ts

@@ -299,14 +299,18 @@ export abstract class ContractBase {
 
     protected $read(abi: string | TAbiItem, ...params) {
         if (this.builderConfig?.send === 'manual') {
+            let abiJson = typeof abi === 'string'
+                ? $abiParser.parseMethod(abi)
+                : abi;
             let req = <ContractReaderUtils.IContractReadParams>{
                 address: this.address,
-                abi,
+                abi: abiJson,
                 params: params,
                 blockNumber: this.blockNumber ?? this.blockDate,
                 options: {
                     from: this.builderConfig?.from
-                }
+                },
+                method: abiJson.name
             };
             return req;
         }

package/src/contracts/ContractReader.ts

@@ -302,9 +302,9 @@ export class ContractReader implements IContractReader {
         return filters as RpcTypes.Filter;
     }
 
-    static async read (client: Web3Client, address: TAddress, methodAbi: string){
+    static async read <TResult = any> (client: Web3Client, address: TAddress, methodAbi: string){
         let reader = new ContractReader(client);
-        return reader.readAsync(address, methodAbi);
+        return reader.readAsync<TResult>(address, methodAbi);
     }
 }
 
@@ -357,43 +357,6 @@ export namespace ContractReaderUtils {
     export async function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[], options?: {
         allowErrors?: boolean
     }) {
-
-        let rpcRequests = await alot(requests).map(async request => {
-            if (request == null) {
-                return null;
-            }
-            let abi = request.abi;
-            if (typeof abi === 'string') {
-                abi = $abiParser.parseMethod(abi);
-            }
-            let blockNumber = request.blockNumber;
-            if (blockNumber instanceof Date) {
-                let resolver = di.resolve(BlockDateResolver, client);
-                blockNumber = await resolver.getBlockNumberFor(blockNumber);
-            }
-            return {
-                address: request.address,
-                abi: [ abi ],
-                method: abi.name,
-                params: request.params,
-                blockNumber: blockNumber,
-                options: request.options
-            } as TRpcContractCall;
-        }).toArrayAsync();
-
-        let mapped = [];
-        let rpcRequestsNotEmpty = [];
-        for (let i = 0; i < rpcRequests.length; i++) {
-            if (rpcRequests[i] == null) {
-                continue;
-            }
-            let idx = rpcRequestsNotEmpty.push(rpcRequests[i]) - 1;
-            mapped[i] = idx;
-        }
-
-        let outputs = await client.readContractBatch(rpcRequestsNotEmpty, options);
-        return rpcRequests.map((_, i) => {
-            return outputs[mapped[i]] ?? null;
-        });
+        return await client.readContractBatch(requests, options);
     }
 }

package/src/explorer/BlockchainExplorerFactory.ts

@@ -58,7 +58,6 @@ export namespace BlockchainExplorerFactory {
 
     /** @obsolete Create instance directly with the get/getAsync method */
     export function create (opts: IBlockchainExplorerFactoryParams): Constructor<IBlockchainExplorer> {
-
         return class extends BlockchainExplorer {
             constructor (config?: IBlockchainExplorerFactoryParams) {
                 super(config ?? opts);

package/src/explorer/IBlockchainExplorer.ts

@@ -3,9 +3,13 @@ import { IAbiProvider } from './IAbiProvider';
 import { TEth } from '@dequanto/models/TEth';
 import { TAddress } from '@dequanto/models/TAddress';
 import { IVerifier } from './verifiers/IVerifier';
+import { TExplorerDefinition } from '@dequanto/models/TExplorer';
 
 
 export interface IBlockchainExplorer extends IAbiProvider, IVerifier {
+    config?: {
+        api?: { url?: string; key?: string }
+    }
     inMemoryDb: IContractDetails[]
     getContractMeta(q: string): Promise<IContractDetails>;
     getContractCreation(address: TEth.Address): Promise<{ creator: TEth.Address, txHash: TEth.Hex }>;

package/src/models/TPlatform.ts

@@ -14,5 +14,6 @@ export type TPlatform = 'eth'
     | 'hardhat'
     | 'optimism'
     | 'avalanche'
+    | 'hh:memory'
     | `hh:${string}`
     | string;

package/src/rpc/RpcContract.ts

@@ -2,11 +2,12 @@ import di from 'a-di';
 import alot from 'alot';
 import { Rpc, RpcTypes } from './Rpc';
 
-import { TAbiItem, TAbiOutput } from '@dequanto/types/TAbi';
+import { TAbiItem } from '@dequanto/types/TAbi';
 import { TAddress } from '@dequanto/models/TAddress';
 import { $require } from '@dequanto/utils/$require';
 import { $abiUtils } from '@dequanto/utils/$abiUtils';
 import { $abiCoder } from '@dequanto/abi/$abiCoder';
+import { $abi } from '@dequanto/abi/$abi';
 import { RpcError } from './RpcError';
 import { $hex } from '@dequanto/utils/$hex';
 import { TEth } from '@dequanto/models/TEth';
@@ -54,7 +55,7 @@ export class RpcContract {
             if (methodAbi == null) {
                 return hex;
             }
-            return utils.deserializeOutput(hex, methodAbi.outputs);
+            return $abi.decodeReturn(methodAbi, hex);
         } catch (err) {
             if (err instanceof RpcError) {
                 err.message = `RpcCall ${req.method} (${JSON.stringify(req.params)}) ${err.message}`;
@@ -82,7 +83,7 @@ export class RpcContract {
                     let defaults = null;
                     try {
                         const defaultHex = $abiCoder.encode(returnABI, [null]);
-                        defaults = utils.deserializeOutput(defaultHex, returnABI);
+                        defaults = $abi.decodeReturn(abi, defaultHex);
                     } catch (error) {}
                     return {
                         defaults,
@@ -90,7 +91,7 @@ export class RpcContract {
                     };
                 }
                 let hex = typeof resp === 'string' ? resp : resp.data;
-                let result = utils.deserializeOutput(hex, returnABI);
+                let result = $abi.decodeReturn(abi, hex);
                 return result;
             });
 
@@ -191,32 +192,3 @@ export class RpcContract {
     // }
 }
 
-
-namespace utils {
-    export function deserializeOutput(hex: string, outputs: TAbiOutput[]) {
-
-        let abi = outputs;
-        let isDynamic: boolean = null;
-        if (outputs.length > 1) {
-            let isNamedTuple = outputs.every(x => x.name != null && x.name !== '');
-            if (isNamedTuple) {
-                // Return as an object
-                abi = [ { type: 'tuple', components: outputs, name: null } ];
-                isDynamic = false;
-            }
-        }
-
-        try {
-            let arr = $abiCoder.decode(abi as any, hex, {
-                dynamic: isDynamic
-            });
-            let value = abi.length === 1 ? arr[0] : arr;
-            return value;
-        } catch (error) {
-            if (outputs.length === 1 && abi.length === 1) {
-                return $abiCoder.decodeSingle(abi[0], hex);
-            }
-            throw error;
-        }
-    }
-}

package/src/utils/$account.ts

@@ -1,6 +1,7 @@
 import { EoAccount, Erc4337Account, SafeAccount, TAccount, TimelockAccount } from "@dequanto/models/TAccount";
 import { $address } from './$address';
 import { $require } from './$require';
+import { $sig } from './$sig';
 
 export namespace $account {
 
@@ -64,4 +65,8 @@ export namespace $account {
         // Optimistic match by pattern "timelock/";
         return rgx.test(account.name);
     }
+
+    export function generate(name: string): EoAccount {
+        return $sig.$account.generate({ name });
+    }
 }

package/src/utils/$config.ts

@@ -16,8 +16,8 @@ export namespace $config {
     let envOptions = null;
 
     export function get <T = any> (path: string, $default?: T): T {
-        let value = (typeof $global.app !== 'undefined' ? $global.app.config?.$get?.(path) : null)
-            ?? obj_getProperty(config, path)
+        let value = obj_getProperty(config, path)
+            ?? (typeof $global.app !== 'undefined' ? $global.app.config?.$get?.(path) : null)
             ?? obj_getProperty(envOptions, path);
 
         if (value == null && envOptions == null) {
@@ -79,11 +79,10 @@ export namespace $config {
         let explorer = $config.get<IConfigData['blockchainExplorer']>(`blockchainExplorer`);
         let chains = $config.get<IConfigData['chains']>('chains', []);
 
-
         let explorerConfig = explorer[platform];
         let chainConfig = chains.find(x => x.platform === platform || x.aliases?.includes(platform));
 
-        $require.notNull(explorerConfig || chainConfig, `Unsupported platform ${platform} for web3 client`);
+        $require.notNull(explorerConfig || chainConfig, `Unsupported platform ${platform} for blockchain explorer`);
         return {
             platform,
             ...(chainConfig?.explorers?.[0] ?? {}),
@@ -92,11 +91,10 @@ export namespace $config {
     }
 
     export function set <T = any> (path: string, value: T) {
+        obj_setProperty(config, path, value);
         if (typeof $global.app?.config?.$set === 'function') {
             $global.app.config.$set(path, value);
-            return;
         }
-        obj_setProperty(config, path, value);
     }
 
     /**

package/src/utils/$erc20.ts

@@ -0,0 +1,53 @@
+import alot from 'alot';
+import { $require } from './$require';
+import { $hex } from './$hex';
+import { $bigint } from './$bigint';
+import { TEth } from '@dequanto/models/TEth';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
+
+export namespace $erc20 {
+    export async function setBalanceAny(client: Web3Client, token: TEth.Address, account: TEth.Address, amount: bigint | number) {
+        $require.eq(client.platform, 'hardhat', `Set Balance available only on Hardhat/Forked network`);
+        const erc20 = new ERC20(token, client);
+        const rpc = await client.getRpc();
+
+        const req = await (erc20.$data() as any).balanceOf(account);
+        const balanceTrace = await rpc.request({
+            method: 'debug_traceCall',
+            params: [
+                req,
+                'latest',
+                {
+                    disableMemory: true,
+                    disableStack: true,
+                    disableStorage: false,
+                }
+            ]
+        }) as {
+            returnValue: TEth.Hex
+            failed: boolean
+            structLogs: {
+                "op": "RETURN",
+                "pc": 1698,
+                "storage": Record<string, TEth.Hex>
+            }[]
+        };
+
+        $require.True(balanceTrace.failed === false, `erc20 balance retrieval failed for ${await erc20.symbol()}`);
+        let returnOp = alot(balanceTrace.structLogs.reverse()).find(x => x.op === 'RETURN');
+        $require.notNull(returnOp, `RETURN opcode not found`);
+        $require.notNull(returnOp.storage, `Storage not found`);
+
+        let returnValue = $hex.raw(balanceTrace.returnValue);
+        let slots = alot.fromObject(returnOp.storage).filter(x => x.value === returnValue).toArray();
+        $require.gt(slots.length, 0, `Slot not found`);
+        let SLOT = $hex.ensure(slots[slots.length - 1].key);
+
+        let balance = typeof amount === 'number'
+            ? await $bigint.toWei(amount, await erc20.decimals())
+            : amount;
+
+        await client.debug.setStorageAt(erc20.address, SLOT, $bigint.toHex(balance));
+    }
+}

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

@@ -61,17 +61,17 @@ export namespace $require {
         }
         return val;
     }
-    export function notNull<T> (val: T, message: string, ...logs): NonNullable<T> {
+    export function notNull<T> (val: T, message?: string, ...logs): NonNullable<T> {
         if (val == null) {
             logs?.forEach(log => console.error(log));
-            throw new Error(`Value is undefined. ${message}`);
+            throw new Error(`Value is undefined. ${message ?? ''}`);
         }
         return val;
     }
-    export function Null<T> (val: T, message: string, ...logs): T {
+    export function Null<T> (val: T, message?: string, ...logs): T {
         if (val != null) {
             logs?.forEach(log => console.error(log));
-            throw new Error(`Value ${val} expects to be undefined. ${message}`);
+            throw new Error(`Value ${val} expects to be undefined. ${message ?? ''}`);
         }
         return val;
     }
@@ -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;
     }
 }

package/tsconfig.json

@@ -6,8 +6,7 @@
         "baseUrl": "./",
         "paths": {
             "@dequanto/*": [ "src/*" ],
-            "dequanto/*": [ "src/*" ],
-            "@dequanto-contracts/*": [ "src/prebuilt/*" ]
+            "dequanto/*": [ "src/*" ]
         },
         "typeRoots": [
             "node_modules/@types",

package/tsconfig.umd.json

@@ -6,8 +6,7 @@
     "compilerOptions": {
         "baseUrl": "./",
         "paths": {
-            "@dequanto/*": [ "src/*" ],
-            "@dequanto-contracts/*": [ "src/prebuilt/*" ]
+            "@dequanto/*": [ "src/*" ]
         },
         "lib": [ "ES2019", "dom" ],
         "typeRoots": [