dequanto 0.2.7 → 0.2.12

package/lib/esm/utils/$traces.mjs

@@ -0,0 +1,486 @@
+import { $abiCoder } from '../abi/$abiCoder.mjs';
+import { $abiUtils } from './$abiUtils.mjs';
+import { $bigint } from './$bigint.mjs';
+import { $hex } from './$hex.mjs';
+import { $color } from './$color.mjs';
+import alot from 'alot';
+export var $traces;
+(function ($traces) {
+    const CALL_OPS = new Set(['CALL', 'STATICCALL', 'DELEGATECALL', 'CALLCODE']);
+    const FAILURE_OPS = new Set(['REVERT', 'INVALID']);
+    async function format(params) {
+        const logs = params.traces.structLogs ?? [];
+        const frames = logs.length > 0
+            ? buildFrames(logs)
+            : [];
+        const abiCache = new Map();
+        const entryAbiMeta = params.tx.to != null
+            ? await getAbiMeta(params.tx.to)
+            : null;
+        const entryAbiItem = getFunctionAbiItem(entryAbiMeta, getSelector(params.tx));
+        if (frames[0] != null) {
+            frames[0].to = params.tx.to ?? null;
+            frames[0].value = params.tx.value ?? null;
+            frames[0].input = getInput(params.tx);
+            frames[0].selector = getSelector(params.tx);
+            frames[0].output = params.traces.returnValue ?? frames[0].output;
+        }
+        await Promise.all(frames.map(async (frame) => {
+            let abiMeta = frame.to != null
+                ? await getAbiMeta(frame.to)
+                : null;
+            let abiItem = getFunctionAbiItem(abiMeta, frame.selector);
+            if (frame.id !== 0) {
+                frame.label = formatFrameLabel(frame, abiMeta?.contractName ?? abiMeta?.name, abiItem, params);
+            }
+            for (let event of frame.events) {
+                event.label = formatEventLabel(event, abiMeta, params);
+            }
+        }));
+        for (let frame of frames) {
+            if (frame.id !== 0) {
+                frame.label ??= formatFrameLabel(frame, null, null, params);
+            }
+            for (let event of frame.events) {
+                event.label ??= formatEventLabel(event, null, params);
+            }
+        }
+        let lines = [];
+        let entryLine = formatEntrypointLabel(params.tx, params.traces, entryAbiMeta?.contractName ?? entryAbiMeta?.name, entryAbiItem, params);
+        lines.push(`${entryLine}${params.traces.failed ? ' [FAILED]' : ''}`);
+        let root = frames[0];
+        if (root != null) {
+            appendEntries(root, 1, lines);
+        }
+        let addresses = alot.fromObject(params.addresses ?? {}).map(x => {
+            return `${x.key} <=> ${x.value}`;
+        }).toArray();
+        lines.push('\n', ...addresses);
+        return lines.join('\n');
+        async function getAbiMeta(contract) {
+            let key = contract.toLowerCase();
+            if (abiCache.has(key) === false) {
+                abiCache.set(key, params.getABI(contract).catch(() => null));
+            }
+            return await abiCache.get(key);
+        }
+        function appendEntries(frame, level, out) {
+            let indent = '  '.repeat(level);
+            let entries = [
+                ...frame.children.map(child => ({ kind: 'frame', index: child.start, frame: child })),
+                ...frame.events.map(event => ({ kind: 'event', index: event.index, event })),
+            ].sort((a, b) => a.index - b.index);
+            for (let entry of entries) {
+                if (entry.kind === 'frame') {
+                    out.push(`${indent}${entry.frame.label}${entry.frame.failed ? ' [FAILED]' : ''}`);
+                    appendEntries(entry.frame, level + 1, out);
+                    continue;
+                }
+                out.push(`${indent}${entry.event.label}`);
+            }
+        }
+    }
+    $traces.format = format;
+    function buildFrames(logs) {
+        let root = {
+            id: 0,
+            parentId: null,
+            depth: logs[0].depth,
+            start: 0,
+            end: logs.length - 1,
+            callSite: null,
+            callOp: 'ROOT',
+            to: null,
+            value: null,
+            input: null,
+            selector: null,
+            output: null,
+            children: [],
+            events: []
+        };
+        let frames = [root];
+        let open = [root];
+        for (let i = 1; i < logs.length; i++) {
+            let prev = logs[i - 1];
+            let current = logs[i];
+            while (open.length > 0 && open[open.length - 1].depth > current.depth) {
+                let closing = open.pop();
+                closing.end = i - 1;
+            }
+            let active = open[open.length - 1];
+            if (current.depth > active.depth) {
+                let meta = CALL_OPS.has(prev.op)
+                    ? getCallMeta(prev)
+                    : { op: prev.op, to: null, value: null, input: null, selector: null };
+                let frame = {
+                    id: frames.length,
+                    parentId: active.id,
+                    depth: current.depth,
+                    start: i,
+                    end: i,
+                    callSite: i - 1,
+                    callOp: meta.op,
+                    to: meta.to,
+                    value: meta.value,
+                    input: meta.input,
+                    selector: meta.selector,
+                    output: null,
+                    children: [],
+                    events: []
+                };
+                active.children.push(frame);
+                frames.push(frame);
+                open.push(frame);
+                active = frame;
+            }
+            let event = getEventMeta(current, i);
+            if (event != null) {
+                active.events.push(event);
+            }
+            active.end = i;
+        }
+        while (open.length > 0) {
+            let frame = open.pop();
+            frame.end = logs.length - 1;
+        }
+        for (let frame of frames) {
+            let endLog = logs[frame.end];
+            frame.exitOp = endLog?.op;
+            frame.failed = FAILURE_OPS.has(frame.exitOp);
+            frame.output = getOutputMeta(endLog);
+        }
+        return frames;
+    }
+    function getCallMeta(log) {
+        let stack = log.stack ?? [];
+        let to = null;
+        let value = null;
+        let inputOffset = 0;
+        let inputSize = 0;
+        if (log.op === 'CALL' || log.op === 'CALLCODE') {
+            if (stack.length < 7) {
+                return { op: log.op, to: null, value: null, input: null, selector: null };
+            }
+            to = toAddress(stack[stack.length - 2]);
+            value = toBigInt(stack[stack.length - 3]);
+            inputOffset = toNumber(stack[stack.length - 4]);
+            inputSize = toNumber(stack[stack.length - 5]);
+        }
+        else if (log.op === 'STATICCALL' || log.op === 'DELEGATECALL') {
+            if (stack.length < 6) {
+                return { op: log.op, to: null, value: null, input: null, selector: null };
+            }
+            to = toAddress(stack[stack.length - 2]);
+            inputOffset = toNumber(stack[stack.length - 3]);
+            inputSize = toNumber(stack[stack.length - 4]);
+        }
+        else {
+            return { op: log.op, to: null, value: null, input: null, selector: null };
+        }
+        let input = readMemory(log.memory ?? [], inputOffset, inputSize);
+        let selector = input != null && input.length >= 10
+            ? input.slice(0, 10)
+            : null;
+        return {
+            op: log.op,
+            to,
+            value,
+            input,
+            selector,
+        };
+    }
+    function getEventMeta(log, index) {
+        let match = /^LOG([0-4])$/.exec(log.op);
+        if (match == null) {
+            return null;
+        }
+        let topicCount = Number(match[1]);
+        let stack = log.stack ?? [];
+        if (stack.length < topicCount + 2) {
+            return null;
+        }
+        let offset = toNumber(stack[stack.length - 1]);
+        let size = toNumber(stack[stack.length - 2]);
+        let topics = Array.from({ length: topicCount }, (_, i) => {
+            return $hex.ensure(stack[stack.length - 3 - i]);
+        });
+        let data = readMemory(log.memory ?? [], offset, size) ?? '0x';
+        return {
+            index,
+            op: log.op,
+            topics,
+            data,
+        };
+    }
+    function readMemory(memory, offset, size) {
+        if (size <= 0 || memory.length === 0) {
+            return null;
+        }
+        let hex = memory.join('');
+        let start = offset * 2;
+        let end = start + size * 2;
+        return `0x${hex.slice(start, end)}`;
+    }
+    function formatEntrypointLabel(tx, traces, contractName, abi, params) {
+        let frame = {
+            id: -1,
+            parentId: null,
+            depth: 0,
+            start: 0,
+            end: 0,
+            callSite: null,
+            callOp: '',
+            to: tx.to ?? null,
+            value: tx.value ?? null,
+            input: getInput(tx),
+            selector: getSelector(tx),
+            output: traces.returnValue ?? null,
+            children: [],
+            events: [],
+            failed: traces.failed,
+            exitOp: null,
+        };
+        return formatFrameLabel(frame, contractName, abi, params);
+    }
+    function formatFrameLabel(frame, contractName, abi, params) {
+        let head = color('gray', frame.callOp.toLowerCase(), params);
+        let suffix = '';
+        if (frame.to != null) {
+            let address = shortAddress(frame.to, params);
+            if (contractName != null && abi != null && 'name' in abi && abi.name != null) {
+                let args = frame.input != null
+                    ? decodeArgs(abi, frame.input, params)
+                    : '';
+                if (params != null) {
+                    params.addresses ??= {};
+                    params.addresses[address] = contractName;
+                }
+                suffix = `${color('bold', contractName, params)}.${color('magenta', abi.name, params)}(${args})`;
+            }
+            else {
+                suffix = `${address}${frame.selector ? ` ${frame.selector}` : ''}`;
+                if (frame.input != null) {
+                    suffix += ` calldata=${shortHex(frame.input, 18, 10)}`;
+                }
+            }
+        }
+        if (frame.value != null && frame.value !== 0n) {
+            suffix += `${suffix ? ' ' : ''}`;
+            if (frame.value && BigInt(frame.value) > 0n) {
+                suffix += `value=${frame.value.toString()}`;
+            }
+        }
+        if (frame.exitOp != null && frame.exitOp !== 'STOP' && frame.exitOp !== 'RETURN') {
+            suffix += `${suffix ? ' ' : ''}exit=${frame.exitOp}`;
+        }
+        if (frame.output != null) {
+            let returnValue = formatReturnValue(frame, abi, params);
+            suffix += `: ${returnValue}`;
+        }
+        return suffix ? `${head} ${suffix}` : head;
+    }
+    function formatEventLabel(event, abiMeta, params) {
+        let abi = getEventAbiItem(abiMeta, event.topics);
+        if (abi == null) {
+            let head = color('cyan', 'event', params);
+            let name = event.topics[0] != null
+                ? shortHex(event.topics[0], 18, 10)
+                : event.op;
+            return `${head} ${name}`;
+        }
+        let args = decodeEventArgs(abi, event, params);
+        return `${color('cyan', 'event', params)} ${color('magenta', abi.name, params)}(${args})`;
+    }
+    function getFunctionAbiItem(abiMeta, selector) {
+        if (abiMeta == null || selector == null) {
+            return null;
+        }
+        return abiMeta.abi.find(item => {
+            if (item.type !== 'function' || !('name' in item)) {
+                return false;
+            }
+            return $abiUtils.getMethodSignature(item) === selector;
+        }) ?? null;
+    }
+    function getEventAbiItem(abiMeta, topics) {
+        if (abiMeta == null) {
+            return null;
+        }
+        return abiMeta.abi.find(item => {
+            if (item.type !== 'event' || !('name' in item) || item.name == null) {
+                return false;
+            }
+            if ('anonymous' in item && item.anonymous === true) {
+                return topics.length === (item.inputs?.filter(x => x.indexed).length ?? 0);
+            }
+            return topics[0] === $abiUtils.getTopicSignature(item);
+        }) ?? null;
+    }
+    function decodeArgs(abi, input, params) {
+        try {
+            let inputs = 'inputs' in abi && Array.isArray(abi.inputs)
+                ? abi.inputs
+                : [];
+            if (inputs.length === 0) {
+                return '';
+            }
+            let data = `0x${input.slice(10)}`;
+            let values = $abiCoder.decode(inputs, data);
+            return inputs.map((param, index) => {
+                let name = param.name?.trim() || `arg${index}`;
+                return `${name}: ${formatValue(values[index], params)}`;
+            }).join(', ');
+        }
+        catch {
+            return shortHex(input, 18, 10);
+        }
+    }
+    function decodeEventArgs(abi, event, params) {
+        try {
+            let inputs = 'inputs' in abi && Array.isArray(abi.inputs)
+                ? abi.inputs
+                : [];
+            if (inputs.length === 0) {
+                return '';
+            }
+            let dataInputs = inputs.filter(x => x.indexed !== true);
+            let dataValues = dataInputs.length > 0
+                ? $abiCoder.decode(dataInputs, event.data)
+                : [];
+            let topicIndex = 'anonymous' in abi && abi.anonymous === true ? 0 : 1;
+            let dataIndex = 0;
+            return inputs.map((param, index) => {
+                let name = param.name?.trim() || `arg${index}`;
+                let value;
+                if (param.indexed === true) {
+                    let topic = event.topics[topicIndex++];
+                    if (topic == null) {
+                        value = 'undefined';
+                    }
+                    else if ($abiUtils.isDynamicType(param.type)) {
+                        value = topic;
+                    }
+                    else {
+                        value = $abiCoder.decode([param], topic)[0];
+                    }
+                }
+                else {
+                    value = dataValues[dataIndex++];
+                }
+                return `${name}: ${formatValue(value, params)}`;
+            }).join(', ');
+        }
+        catch {
+            let rendered = [
+                ...event.topics.map(topic => shortHex(topic, 18, 10)),
+                event.data !== '0x' ? shortHex(event.data, 18, 10) : null,
+            ].filter(Boolean);
+            return rendered.join(', ');
+        }
+    }
+    function formatReturnValue(frame, abi, params) {
+        if (frame.output == null) {
+            return '0x';
+        }
+        if (frame.failed !== true && abi != null) {
+            try {
+                let outputs = 'outputs' in abi && Array.isArray(abi.outputs)
+                    ? abi.outputs
+                    : [];
+                if (outputs.length > 0) {
+                    let values = $abiCoder.decode(outputs, frame.output);
+                    return outputs.map((param, index) => {
+                        let name = param.name?.trim();
+                        if (!name && outputs.length > 1) {
+                            name = `out${index}`;
+                        }
+                        if (name) {
+                            name += ': ';
+                        }
+                        return `${name ?? ''}${formatValue(values[index], params)}`;
+                    }).join(', ');
+                }
+            }
+            catch {
+                // Fall back to raw bytes if decoding fails.
+            }
+        }
+        return shortHex(frame.output, 18, 10);
+    }
+    function getOutputMeta(log) {
+        if (log == null || (log.op !== 'RETURN' && log.op !== 'REVERT')) {
+            return null;
+        }
+        let stack = log.stack ?? [];
+        if (stack.length < 2) {
+            return null;
+        }
+        let offset = toNumber(stack[stack.length - 1]);
+        let size = toNumber(stack[stack.length - 2]);
+        return readMemory(log.memory ?? [], offset, size);
+    }
+    function getInput(tx) {
+        return tx.data ?? tx.input ?? null;
+    }
+    function getSelector(tx) {
+        let input = getInput(tx);
+        return input != null && input.length >= 10
+            ? input.slice(0, 10)
+            : null;
+    }
+    function formatValue(value, params) {
+        if (typeof value === 'bigint') {
+            return color('cyan', value.toString(), params);
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map(x => formatValue(x, params)).join(', ')}]`;
+        }
+        if (value != null && typeof value === 'object') {
+            let entries = Object.entries(value);
+            return `{ ${entries.map(([key, val]) => `${key}: ${formatValue(val, params)}`).join(', ')} }`;
+        }
+        if (typeof value === 'string') {
+            if (/^0x[a-fA-F0-9]{40}$/.test(value)) {
+                return value;
+            }
+            if (/^0x[a-fA-F0-9]{18,}$/.test(value)) {
+                return shortHex(value, 18, 10);
+            }
+            return color('yellow', value, params);
+        }
+        return String(value);
+    }
+    function shortAddress(address, params) {
+        if (params.shortAddress === false) {
+            return address;
+        }
+        return `${address.slice(0, 8)}...${address.slice(-4)}`;
+    }
+    function shortHex(hex, start, end) {
+        if (hex.length <= start + end) {
+            return hex;
+        }
+        return `${hex.slice(0, start)}...${hex.slice(-end)}`;
+    }
+    function toAddress(word) {
+        let hex = word.replace(/^0x/, '').slice(-40).toLowerCase();
+        return `0x${hex}`;
+    }
+    function toBigInt(word) {
+        return $bigint.from($hex.ensure(word));
+    }
+    function toNumber(word) {
+        let value = toBigInt(word);
+        return value > BigInt(Number.MAX_SAFE_INTEGER)
+            ? Number.MAX_SAFE_INTEGER
+            : Number(value);
+    }
+    function color(name, str, params) {
+        if (!params.color) {
+            return str;
+        }
+        return $color(`${name}<${str}>`);
+    }
+})($traces || ($traces = {}));
+//# sourceMappingURL=$traces.js.map
+//# sourceMappingURL=$traces.ts.map

package/lib/types/clients/debug/ClientDebugMethods.d.ts

@@ -27,5 +27,23 @@ export declare class ClientDebugMethods {
     snapshot(): Promise<number>;
     revert(snapId: number): Promise<any>;
     setAutomine(enabled: boolean): Promise<any>;
+    traceCall(data: TEth.TxLike, block?: number | string | 'latest', params?: {
+        disableMemory?: boolean;
+        disableStack?: boolean;
+        disableStorage?: boolean;
+    }): Promise<TClientDebugTraces>;
     private call;
 }
+export type TClientDebugTraces = {
+    failed?: boolean;
+    returnValue?: TEth.Hex;
+    structLogs?: {
+        depth: number;
+        gas: number;
+        gasCost: number;
+        op: string;
+        pc: number;
+        memory?: string[];
+        stack?: string[];
+    }[];
+};

package/lib/types/clients/interfaces/IWeb3Client.d.ts

@@ -57,5 +57,9 @@ export interface IWeb3ClientOptions {
             call: 'evm_setAutomine' | string;
             params: 1 | number;
         };
+        traceCall?: {
+            call: 'debug_traceCall' | string;
+            params: 3 | number;
+        };
     };
 }

package/lib/types/models/TEth.d.ts

@@ -143,8 +143,8 @@ export declare namespace TEth {
         [P in keyof T]?: T[P] extends bigint ? bigint | number | string | TEth.Hex : (T[P] extends number ? number | TEth.Hex | bigint : (T[P] extends [] ? DataLike<T[P][0]>[] : DataLike<T[P]>));
     };
     namespace Abi {
-        type Type = 'function' | 'constructor' | 'event' | 'fallback';
-        type StateMutabilityType = 'pure' | 'view' | 'nonpayable' | 'payable';
+        type Type = 'function' | 'constructor' | 'event' | 'error' | 'fallback' | 'receive';
+        type StateMutabilityType = 'constant' | 'pure' | 'view' | 'nonpayable' | 'payable';
         interface Item {
             anonymous?: boolean;
             constant?: boolean;

package/lib/types/utils/$color.d.ts

@@ -2,3 +2,65 @@ export declare function $color(str: string): string;
 export declare function $color_options(opts: {
     type: 'none' | 'ascii';
 }): void;
+export declare namespace ColorData {
+    const ColorAscii: {
+        type: string;
+        START: string;
+        END: string;
+        value: {
+            red: string;
+            green: string;
+            yellow: string;
+            blue: string;
+            magenta: string;
+            cyan: string;
+            white: string;
+            black: string;
+            gray: string;
+            bg_black: string;
+            bg_red: string;
+            bg_green: string;
+            bg_yellow: string;
+            bg_blue: string;
+            bg_magenta: string;
+            bg_cyan: string;
+            bg_white: string;
+            bold: string;
+            italic: string;
+            underline: string;
+            inverse: string;
+        };
+        start(key: any): any;
+        rgx_search: RegExp;
+    };
+    const ColorNone: {
+        type: string;
+        END: string;
+        START: string;
+        value: {
+            red: string;
+            green: string;
+            yellow: string;
+            blue: string;
+            magenta: string;
+            cyan: string;
+            white: string;
+            black: string;
+            gray: string;
+            bg_black: string;
+            bg_red: string;
+            bg_green: string;
+            bg_yellow: string;
+            bg_blue: string;
+            bg_magenta: string;
+            bg_cyan: string;
+            bg_white: string;
+            bold: string;
+            italic: string;
+            underline: string;
+            inverse: string;
+        };
+        start: (key: any) => string;
+        rgx_search: RegExp;
+    };
+}

package/lib/types/utils/$contract.d.ts

@@ -36,7 +36,15 @@ export declare namespace $contract {
     namespace store {
         function getFlattened(): TAbiItem[];
         function register(contract: {
+            address?: TEth.Address;
+            name?: string;
             abi: TAbiItem[];
         }): void;
+        function getContract(address: TEth.Address): {
+            name?: string;
+            address?: TEth.Address;
+            abi: TAbiItem[];
+        };
+        function getAbiItem(selector: TEth.Hex): TAbiItem;
     }
 }

package/lib/types/utils/$require.d.ts

@@ -25,6 +25,8 @@ export declare namespace $require {
     function eq<T = any>(a: T, b: T, message?: string): void;
     function match(rgx: RegExp, str: string, message?: string): void;
     function oneOf<T = any>(a: T, arr: T[], message?: string): void;
+    function has<T = any>(a: T, arr: T[], message?: string): any;
+    function has<T = any>(a: string, str: string, message?: string): any;
     function Address(val: TAddress | string, message?: string): TAddress;
     function AddressNotEmpty(val: TAddress | string, message?: string): TAddress;
     function AddressChecked(val: TAddress, message?: string): TAddress;

package/lib/types/utils/$traces.d.ts

@@ -0,0 +1,18 @@
+import { TClientDebugTraces } from '../clients/debug/ClientDebugMethods';
+import { TEth } from '../models/TEth';
+export declare namespace $traces {
+    type TAbiMeta = {
+        name?: string;
+        contractName?: string;
+        abi: TEth.Abi.Item[];
+    };
+    export function format(params: {
+        tx: TEth.TxLike;
+        traces: TClientDebugTraces;
+        getABI(contract: TEth.Address): Promise<TAbiMeta>;
+        color?: boolean;
+        shortAddress?: boolean;
+        addresses?: Record<TEth.Address, string>;
+    }): Promise<string>;
+    export {};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.2.7",
+    "version": "0.2.12",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"