@ton/sandbox 0.30.0 → 0.31.0

package/dist/metric/ContractDatabase.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractDatabase = void 0;
+const collectMetric_1 = require("./collectMetric");
+class ContractDatabase {
+    constructor(abiList, codeHashMatch) {
+        this.list = abiList;
+        this.match = codeHashMatch;
+    }
+    static from(data) {
+        const list = new Map();
+        const match = new Map();
+        Object.entries(data).forEach(([key, value]) => {
+            if (((0, collectMetric_1.isCodeHash)(key) && typeof value === 'string') || ((0, collectMetric_1.isCodeHash)(value) && typeof key === 'string')) {
+                match.set(key, value);
+            }
+            else if (!(0, collectMetric_1.isCodeHash)(value) && typeof value !== 'string') {
+                list.set(key, value);
+            }
+        });
+        return new ContractDatabase(list, match);
+    }
+    get data() {
+        const out = {};
+        for (const [key, value] of this.match) {
+            out[key] = value;
+        }
+        for (const [key, value] of this.list) {
+            out[key] = value;
+        }
+        return out;
+    }
+    origin(needle) {
+        return this.match.get(needle) || needle;
+    }
+    get(needle) {
+        return this.list.get(this.origin(needle));
+    }
+    extract(metric) {
+        const abiKeyNeedle = metric.contractName || metric.codeHash;
+        if (!abiKeyNeedle) {
+            return;
+        }
+        const codeHash = metric.codeHash;
+        if ((0, collectMetric_1.isCodeHash)(codeHash) && abiKeyNeedle !== codeHash) {
+            this.match.set(codeHash, abiKeyNeedle);
+        }
+        const abiKey = this.origin(abiKeyNeedle);
+        const abi = this.list.get(abiKey) || {};
+        if (!abi.receivers) {
+            abi.receivers = [];
+        }
+        if (!abi.types) {
+            abi.types = [];
+        }
+        const find = this.by(metric);
+        if (!find.methodName) {
+            if (!abi.name) {
+                abi.name = metric.contractName || metric.codeHash;
+            }
+            if (metric.opCode !== '0x0') {
+                abi.types.push({
+                    name: metric.methodName || metric.opCode,
+                    header: Number(metric.opCode),
+                });
+                abi.receivers.push({
+                    receiver: metric.receiver == 'internal' ? 'internal' : 'external',
+                    message: {
+                        kind: 'typed',
+                        type: metric.methodName || metric.opCode,
+                    },
+                });
+            }
+        }
+        this.list.set(abiKey, abi);
+    }
+    by(where) {
+        if (!where.codeHash) {
+            return {};
+        }
+        const abi = this.get(where.codeHash);
+        if (!abi) {
+            return {};
+        }
+        const out = {};
+        out.contractName = abi.name ? abi.name : undefined;
+        let abiType;
+        if (where.opCode) {
+            for (const item of abi.types || []) {
+                if (item.header && item.header === Number(where.opCode)) {
+                    abiType = item;
+                    break;
+                }
+            }
+        }
+        if (abiType) {
+            const receiver = where.receiver ? (where.receiver == 'internal' ? 'internal' : 'external') : undefined;
+            for (const item of abi.receivers || []) {
+                if (receiver && receiver !== item.receiver) {
+                    continue;
+                }
+                if (item.message.kind === 'typed' && item.message.type == abiType.name) {
+                    out.methodName = item.message.type;
+                    break;
+                }
+            }
+        }
+        return out;
+    }
+}
+exports.ContractDatabase = ContractDatabase;

package/dist/metric/collectMetric.d.ts

@@ -0,0 +1,106 @@
+import { Cell, Contract, Message } from '@ton/core';
+import { Dictionary, DictionaryKeyTypes, TransactionComputePhase } from '@ton/core';
+import { Maybe } from '@ton/core/src/utils/maybe';
+import { Blockchain, SendMessageResult } from '../blockchain/Blockchain';
+import { ContractDatabase } from './ContractDatabase';
+export type MetricContext<T extends Contract> = {
+    contract: T;
+    methodName: string;
+};
+type StateShort = {
+    code: Cell;
+    data: Cell;
+};
+export type CellMetric = {
+    cells: number;
+    bits: number;
+};
+export type ComputePhaseMetric = {
+    type: string;
+    success?: boolean;
+    gasUsed?: number;
+    exitCode?: number;
+    vmSteps?: number;
+};
+export type ActionPhaseMetric = {
+    success: boolean;
+    totalActions: number;
+    skippedActions: number;
+    resultCode: number;
+    totalFwdFees?: number;
+    totalActionFees: number;
+    totalMessageSize: CellMetric;
+};
+export type AddressFriendly = string;
+export declare function isAddressFriendly(value: unknown): value is AddressFriendly;
+export type ContractName = string;
+export type ContractMethodName = string;
+export type CodeHash = `0x${string}`;
+export type OpCode = `0x${string}`;
+export declare function isCodeHash(value: unknown): value is CodeHash;
+export type StateMetric = {
+    code: CellMetric;
+    data: CellMetric;
+};
+export type Metric = {
+    testName?: string;
+    address: AddressFriendly;
+    codeHash?: CodeHash;
+    state: StateMetric;
+    contractName?: ContractName;
+    methodName?: ContractMethodName;
+    receiver?: 'internal' | 'external-in' | 'external-out';
+    opCode: OpCode;
+    execute: {
+        compute: ComputePhaseMetric;
+        action?: ActionPhaseMetric;
+    };
+    message: {
+        in: CellMetric;
+        out: CellMetric;
+    };
+};
+export type SnapshotMetric = {
+    label: string;
+    createdAt: Date;
+    items: Metric[];
+};
+interface HasCreatedAt {
+    createdAt: Date;
+}
+export declare function sortByCreatedAt(reverse?: boolean): (a: HasCreatedAt, b: HasCreatedAt) => number;
+export type SnapshotMetricFile = {
+    name: string;
+    content: SnapshotMetric;
+};
+export type SnapshotMetricList = Record<string, SnapshotMetricFile>;
+export type SnapshotMetricConfig = {
+    label: string;
+    contractExcludes: ContractName[];
+    contractDatabase: ContractDatabase;
+};
+export declare function makeSnapshotMetric(store: Metric[], config?: Partial<SnapshotMetricConfig>): SnapshotMetric;
+export declare function getMetricStore(context?: any): Array<Metric> | undefined;
+export declare function createMetricStore(context?: any): Array<Metric>;
+export declare function resetMetricStore(context?: any): Array<Metric>;
+export declare function calcMessageSize(msg: Maybe<Message>): {
+    cells: number;
+    bits: number;
+};
+export declare function calcDictSize<K extends DictionaryKeyTypes, V>(dict: Dictionary<K, V>): {
+    cells: number;
+    bits: number;
+};
+export declare function calcCellSize(root: Cell, visited?: Set<string>): {
+    cells: number;
+    bits: number;
+};
+export declare function calcStateSize(state: StateShort): StateMetric;
+export declare function calcComputePhase(phase: TransactionComputePhase): ComputePhaseMetric;
+export declare enum OpCodeReserved {
+    send = 0,
+    notSupported = 4294967295,
+    notAllowed = 4294967294
+}
+export declare function collectMetric<T extends Contract>(blockchain: Blockchain, ctx: MetricContext<T>, result: SendMessageResult): Promise<void>;
+export {};

package/dist/metric/collectMetric.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectMetric = exports.OpCodeReserved = exports.calcComputePhase = exports.calcStateSize = exports.calcCellSize = exports.calcDictSize = exports.calcMessageSize = exports.resetMetricStore = exports.createMetricStore = exports.getMetricStore = exports.makeSnapshotMetric = exports.sortByCreatedAt = exports.isCodeHash = exports.isAddressFriendly = void 0;
+const core_1 = require("@ton/core");
+const ContractDatabase_1 = require("./ContractDatabase");
+function isAddressFriendly(value) {
+    return typeof value === 'string' && core_1.Address.isFriendly(value);
+}
+exports.isAddressFriendly = isAddressFriendly;
+function isCodeHash(value) {
+    return typeof value === 'string' && value.length === 66 && /^0x[0-9a-fA-F]+$/.test(value);
+}
+exports.isCodeHash = isCodeHash;
+function sortByCreatedAt(reverse = false) {
+    return (a, b) => (a.createdAt.getTime() - b.createdAt.getTime()) * (reverse ? -1 : 1);
+}
+exports.sortByCreatedAt = sortByCreatedAt;
+const STORE_METRIC = Symbol.for('ton-sandbox-metric-store');
+function makeSnapshotMetric(store, config = {}) {
+    const label = config.label || 'current';
+    const contractExcludes = config.contractExcludes || new Array();
+    const contractDatabase = config.contractDatabase || ContractDatabase_1.ContractDatabase.from({});
+    const snapshot = {
+        label,
+        createdAt: new Date(),
+        items: new Array(),
+    };
+    // remove duplicates and extract ABI
+    const seen = new Set();
+    for (const metric of store) {
+        const key = JSON.stringify(metric);
+        if (seen.has(key))
+            continue;
+        snapshot.items.push(metric);
+        seen.add(key);
+        if (metric.codeHash) {
+            contractDatabase.extract(metric);
+        }
+    }
+    // ABI auto-mapping
+    for (const item of snapshot.items) {
+        const find = contractDatabase.by(item);
+        if (!item.contractName && find.contractName) {
+            item.contractName = find.contractName;
+        }
+        if (!item.methodName && find.methodName) {
+            item.methodName = find.methodName;
+        }
+    }
+    if (contractExcludes.length > 0) {
+        snapshot.items = snapshot.items.filter((it) => typeof it.contractName === 'undefined' || !contractExcludes.includes(it.contractName));
+    }
+    return snapshot;
+}
+exports.makeSnapshotMetric = makeSnapshotMetric;
+function getMetricStore(context = globalThis) {
+    return context[STORE_METRIC];
+}
+exports.getMetricStore = getMetricStore;
+function createMetricStore(context = globalThis) {
+    if (!Array.isArray(context[STORE_METRIC])) {
+        context[STORE_METRIC] = new Array();
+    }
+    return context[STORE_METRIC];
+}
+exports.createMetricStore = createMetricStore;
+function resetMetricStore(context = globalThis) {
+    const store = getMetricStore(context);
+    if (store)
+        store.length = 0;
+    return createMetricStore(context);
+}
+exports.resetMetricStore = resetMetricStore;
+function calcMessageSize(msg) {
+    if (msg) {
+        return calcCellSize((0, core_1.beginCell)().store((0, core_1.storeMessage)(msg)).endCell());
+    }
+    return { cells: 0, bits: 0 };
+}
+exports.calcMessageSize = calcMessageSize;
+function calcDictSize(dict) {
+    if (dict.size > 0) {
+        return calcCellSize((0, core_1.beginCell)().storeDict(dict).endCell().asSlice().loadRef());
+    }
+    return { cells: 0, bits: 0 };
+}
+exports.calcDictSize = calcDictSize;
+function calcCellSize(root, visited = new Set()) {
+    const hash = root.hash().toString('hex');
+    if (visited.has(hash)) {
+        return { cells: 0, bits: 0 };
+    }
+    visited.add(hash);
+    const out = {
+        cells: 1,
+        bits: root.bits.length,
+    };
+    for (const ref of root.refs) {
+        const childRes = calcCellSize(ref, visited);
+        out.cells += childRes.cells;
+        out.bits += childRes.bits;
+    }
+    return out;
+}
+exports.calcCellSize = calcCellSize;
+function calcStateSize(state) {
+    const codeSize = calcCellSize(state.code);
+    const dataSize = calcCellSize(state.data);
+    return {
+        code: codeSize,
+        data: dataSize,
+    };
+}
+exports.calcStateSize = calcStateSize;
+function calcComputePhase(phase) {
+    if (phase.type === 'vm') {
+        return {
+            type: phase.type,
+            success: phase.success,
+            gasUsed: Number(phase.gasUsed),
+            exitCode: phase.exitCode,
+            vmSteps: phase.vmSteps,
+        };
+    }
+    return {
+        type: phase.type,
+    };
+}
+exports.calcComputePhase = calcComputePhase;
+var OpCodeReserved;
+(function (OpCodeReserved) {
+    OpCodeReserved[OpCodeReserved["send"] = 0] = "send";
+    OpCodeReserved[OpCodeReserved["notSupported"] = 4294967295] = "notSupported";
+    OpCodeReserved[OpCodeReserved["notAllowed"] = 4294967294] = "notAllowed";
+})(OpCodeReserved = exports.OpCodeReserved || (exports.OpCodeReserved = {}));
+async function collectMetric(blockchain, ctx, result) {
+    const store = getMetricStore();
+    if (!Array.isArray(store)) {
+        return;
+    }
+    let state = { data: { cells: 0, bits: 0 }, code: { cells: 0, bits: 0 } };
+    let codeHash;
+    if (ctx.contract.init && ctx.contract.init.code && ctx.contract.init.data) {
+        codeHash = `0x${ctx.contract.init.code.hash().toString('hex')}`;
+        state = calcStateSize({ code: ctx.contract.init.code, data: ctx.contract.init.data });
+    }
+    else {
+        const account = (await blockchain.getContract(ctx.contract.address)).accountState;
+        if (account && account.type === 'active' && account.state.code && account.state.data) {
+            codeHash = `0x${account.state.code.hash().toString('hex')}`;
+            state = calcStateSize({ code: account.state.code, data: account.state.data });
+        }
+    }
+    let testName;
+    if (globalThis['expect']) {
+        testName = expect.getState().currentTestName;
+    }
+    let contractName = ctx.contract.constructor.name;
+    let methodName = ctx.methodName;
+    for (const tx of result.transactions) {
+        if (tx.description.type !== 'generic')
+            continue;
+        const receiver = tx.inMessage?.info.type;
+        const body = tx.inMessage?.body ? tx.inMessage.body.beginParse() : undefined;
+        let opCode = '0x0';
+        if (receiver === 'internal') {
+            opCode = `0x${(body && body.remainingBits >= 32 ? body.preloadUint(32) : 0).toString(16)}`;
+        }
+        if (!methodName && Object.values(OpCodeReserved).includes(Number(opCode))) {
+            methodName = OpCodeReserved[Number(opCode)];
+        }
+        const address = core_1.Address.parseRaw(`0:${tx.address.toString(16).padStart(64, '0')}`);
+        const { computePhase, actionPhase, bouncePhase, storagePhase } = tx.description;
+        const action = actionPhase
+            ? {
+                success: actionPhase.success,
+                totalActions: actionPhase.totalActions,
+                skippedActions: actionPhase.skippedActions,
+                resultCode: actionPhase.resultCode,
+                totalActionFees: actionPhase.totalActions,
+                totalFwdFees: actionPhase.totalFwdFees ? Number(actionPhase.totalFwdFees) : undefined,
+                totalMessageSize: {
+                    cells: Number(actionPhase.totalMessageSize.cells),
+                    bits: Number(actionPhase.totalMessageSize.bits),
+                },
+            }
+            : undefined;
+        const compute = calcComputePhase(computePhase);
+        const metric = {
+            testName,
+            address: address.toString(),
+            codeHash,
+            contractName,
+            methodName,
+            receiver,
+            opCode,
+            execute: {
+                compute,
+                action,
+            },
+            message: {
+                in: calcMessageSize(tx.inMessage),
+                out: calcDictSize(tx.outMessages),
+            },
+            state,
+        };
+        store.push(metric);
+        methodName = undefined;
+        if (!address.equals(ctx.contract.address)) {
+            contractName = ctx.contract.constructor.name;
+        }
+        else {
+            contractName = undefined;
+        }
+    }
+}
+exports.collectMetric = collectMetric;

package/dist/metric/defaultColor.d.ts

@@ -0,0 +1,2 @@
+import { DeltaMetric } from './deltaResult';
+export declare function defaultColor(metric: DeltaMetric): string;

package/dist/metric/defaultColor.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultColor = void 0;
+const chalk_1 = __importStar(require("chalk"));
+function defaultColor(metric) {
+    if (!chalk_1.supportsColor) {
+        return metric.value;
+    }
+    const { green, redBright, gray, yellowBright } = chalk_1.default;
+    let color = gray;
+    if (metric.kind === 'decrease') {
+        color = green;
+    }
+    else if (metric.kind === 'increase') {
+        color = redBright;
+    }
+    else if (metric.kind === 'undefined') {
+        color = yellowBright;
+    }
+    return color(metric.value);
+}
+exports.defaultColor = defaultColor;

package/dist/metric/deltaResult.d.ts

@@ -0,0 +1,39 @@
+import { AddressFriendly, ContractMethodName, ContractName, Metric, OpCode, SnapshotMetric } from './collectMetric';
+export type KindDelta = 'undefined' | 'init' | 'same' | 'increase' | 'decrease';
+export type PathDelta = string;
+export type ItemDelta = {
+    kind: KindDelta;
+    path: PathDelta;
+    before: number;
+    after: number;
+};
+export type ListDelta = Record<PathDelta, ItemDelta>;
+export type DeltaMetric = {
+    kind: KindDelta;
+    value: string;
+};
+export declare const undefinedDeltaMetric: () => DeltaMetric;
+export type ColorDelta = (metric: DeltaMetric) => string;
+export type DeltaMetrics = Record<string, DeltaMetric>;
+export type MethodDelta = Record<ContractMethodName | OpCode, DeltaMetrics>;
+export type ContractDelta = Record<ContractName | AddressFriendly, MethodDelta>;
+export type DeltaResult = {
+    label: string;
+    createdAt: Date;
+    result: ContractDelta;
+};
+export type DeltaRow = [contract: string, method: string, ...values: DeltaMetric[]];
+export type FlatDeltaResult = {
+    header: string[];
+    rows: DeltaRow[];
+};
+export declare function toFlatDeltaResult(deltas: DeltaResult[]): {
+    header: string[];
+    rows: DeltaRow[];
+};
+export declare function aggregatedCompareMetric(before: Metric, after: Metric, basePath?: string[]): ListDelta;
+export declare function prepareDelta(pair: {
+    after: SnapshotMetric;
+    before?: SnapshotMetric;
+}): DeltaResult;
+export declare function makeGasReport(list: SnapshotMetric[]): Array<DeltaResult>;