dequanto 0.2.8 → 0.2.12

package/src/clients/debug/ClientDebugMethods.ts

@@ -83,30 +83,39 @@ export class ClientDebugMethods {
         return this.call('autoMine', enabled);
     }
 
+    traceCall (data: TEth.TxLike, block?: number | string | 'latest', params?: {
+        disableMemory?: boolean
+        disableStack?: boolean
+        disableStorage?: boolean
+    }): Promise<TClientDebugTraces> {
+        return this.call('traceCall', data, block ?? 'latest', params);
+    }
+
     private call(method: keyof typeof this.methods, ...args: any[]) {
         let meta = this.methods[method];
         if (meta?.call == null) {
             throw new Error(`RPC method for ${method} is not configured in ${this.client.platform}`);
         }
         return this.client.pool.call(web3 => {
-            //let eth = web3.eth as (typeof web3.eth & { [key in typeof method]: Function });
-
             return web3.rpc.request({
                 method: meta.call,
                 params: args
             });
-            // if (eth[method] == null) {
-            //     web3.eth.extend({
-            //         methods: [
-            //             {
-            //                 name: method,
-            //                 call: meta.call,
-            //                 params: meta.params,
-            //             }
-            //         ]
-            //     });
-            // }
-            // return eth[method](...args);
         })
     }
 }
+
+
+export type TClientDebugTraces = {
+    failed?: boolean
+    returnValue?: TEth.Hex
+    structLogs?: {
+        depth: number
+        gas: number
+        gasCost: number
+        op: string
+        pc: number
+        memory?: string[]
+        stack?: string[]
+    }[]
+}

package/src/clients/interfaces/IWeb3Client.ts

@@ -65,6 +65,10 @@ export interface IWeb3ClientOptions {
         autoMine?: {
             call: 'evm_setAutomine' | string,
             params: 1 | number
+        },
+        traceCall?: {
+            call: 'debug_traceCall' | string,
+            params: 3 | number
         }
     }
 }

package/src/hardhat/HardhatProvider.ts

@@ -218,7 +218,10 @@ export class HardhatProvider {
         const receipt = await Factory.deploy();
         const { contract, ContractCtor } = await ContractClassFactory.fromAbi<TReturn>(receipt.contractAddress, abi, client, null);
         const explorer = await this.explorer();
-        explorer.inMemoryDb.push({ name: '', abi: abi, address: receipt.contractAddress });
+
+        const meta = { name: options?.contractName, abi: abi, address: receipt.contractAddress };
+        explorer.inMemoryDb.push(meta);
+        $contract.store.register(meta);
 
         return {
             contract,
@@ -259,7 +262,9 @@ export class HardhatProvider {
         const { contract, ContractCtor } = await ContractClassFactory.fromAbi<TReturn>(receipt.contractAddress, abi, client, null);
 
         const explorer = await this.explorer();
-        explorer.inMemoryDb.push({ name: '', abi: abi, address: receipt.contractAddress });
+        const meta = { name: options.contractName, abi: abi, address: receipt.contractAddress };
+        explorer.inMemoryDb.push(meta);
+        $contract.store.register(meta);
         return {
             contract,
             ContractCtor,
@@ -354,7 +359,6 @@ export class HardhatProvider {
         const hh = await this.getHardhat();
         await hh.run('compile', hhOptions);
 
-
         return await this.getContractFromSolPath<T> (solContractPath, {
             contractName: options?.contractName,
             paths
@@ -413,6 +417,7 @@ export class HardhatProvider {
         if (contractName == null) {
             let matches = Array.from(solidityCode.matchAll(/contract\s+(?<name>[\w]+)/g));
             contractName = matches[matches.length - 1].groups.name;
+            options.contractName = contractName;
         }
         $require.notNull(contractName, `Contract name not resolved from the code`);
         let rnd = $number.randomInt(0, 10**10);

package/src/hardhat/HardhatWeb3Client.ts

@@ -62,6 +62,10 @@ export class HardhatWeb3Client extends Web3Client {
                 autoMine: {
                     call: 'evm_setAutomine',
                     params: 1
+                },
+                traceCall: {
+                    call: 'debug_traceCall',
+                    params: 3
                 }
             }
         });

package/src/models/TEth.ts

@@ -192,8 +192,8 @@ export namespace TEth {
     }
 
     export namespace Abi {
-        export type Type = 'function' | 'constructor' | 'event' | 'fallback';
-        export type StateMutabilityType = 'pure' | 'view' | 'nonpayable' | 'payable';
+        export type Type = 'function' | 'constructor' | 'event' | 'error' | 'fallback' | 'receive';
+        export type StateMutabilityType = 'constant' | 'pure' | 'view' | 'nonpayable' | 'payable';
 
         export interface Item {
             anonymous?: boolean;

package/src/txs/TxDataBuilder.ts

@@ -13,6 +13,7 @@ import { $abiUtils } from '@dequanto/utils/$abiUtils';
 import { $hex } from '@dequanto/utils/$hex';
 import { $contract } from '@dequanto/utils/$contract';
 import { TxNonceManager } from './TxNonceManager';
+import { $traces } from '@dequanto/utils/$traces';
 
 export class TxDataBuilder {
 
@@ -268,6 +269,25 @@ export class TxDataBuilder {
             if (parsed) {
                 message += `\nMethod: ` + $contract.formatCall(parsed);
             }
+            if (this.client.debug && this.client.debug.traceCall) {
+                try {
+                    let txData = { from, ...this.data };
+                    let traces = await this.client.debug.traceCall(txData);
+                    let output = await $traces.format({
+                        tx: txData,
+                        traces,
+                        color: false,
+                        shortAddress: false,
+                        async getABI(address) {
+                            return $contract.store.getContract(address);
+                        }
+                    });
+                    message += `\nTraces: \n` + output;
+                } catch (error) {
+                    // ignore
+                }
+            }
+
             throw new Error(message);
         }
     }

package/src/types/TAbi.ts

@@ -1,6 +1,6 @@
 
 export type AbiType = 'function' | 'constructor' | 'event' | 'error' | 'fallback' | 'receive';
-export type StateMutabilityType = 'constant' |'pure' | 'view' | 'nonpayable' | 'payable';
+export type StateMutabilityType = 'constant' | 'pure' | 'view' | 'nonpayable' | 'payable';
 
 export interface TAbiItem {
     anonymous?: boolean;

package/src/utils/$color.ts

@@ -20,7 +20,7 @@ export function $color_options(opts: { type: 'none' | 'ascii' }) {
         : ColorData.ColorAscii
 };
 
-namespace ColorData {
+export namespace ColorData {
 
     export const ColorAscii = {
         type: 'ascii',

package/src/utils/$contract.ts

@@ -295,15 +295,31 @@ export namespace $contract {
 
     export namespace store {
         const knownContracts = [] as {
+            name?: string
+            address?: TEth.Address
             abi: TAbiItem[]
         }[];
 
         export function getFlattened() {
             return alot(knownContracts).mapMany(x => x.abi).toArray();
         }
-        export function register(contract: { abi: TAbiItem[] }) {
+        export function register(contract: {
+            address?: TEth.Address
+            name?: string
+            abi: TAbiItem[]
+        }) {
             knownContracts.push(contract)
         }
+
+        export function getContract(address: TEth.Address) {
+            return knownContracts.find(x => x.address === address);
+        }
+
+        export function getAbiItem(selector: TEth.Hex) {
+            return getFlattened().find(item => {
+                return $abiUtils.getMethodSignature(item) === selector;
+            });
+        }
     }
 
     function formatJson(json) {

package/src/utils/$require.ts

@@ -126,6 +126,15 @@ export namespace $require {
         }
     }
 
+    export function has<T = any>(a: T, arr: T[], message?: string)
+    export function has<T = any>(a: string, str: string, message?: string)
+    export function has<T = any>(a: T, mix: T[] | string, message: string = '') {
+        // not strict equal
+        if (mix.includes(a as any) === false) {
+            throw new Error(`${a} should be contain ${typeof mix === 'string' ? mix : mix.join(', ')}. ${message}`)
+        }
+    }
+
     export function Address (val: TAddress | string, message: string = ''): TAddress {
         if ($is.Address(val) === false) {
             throw new Error(`Value ${val} is not a valid address. ${message}`);