@ton/sandbox 0.30.0 → 0.31.0

package/dist/metric/deltaResult.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGasReport = exports.prepareDelta = exports.aggregatedCompareMetric = exports.toFlatDeltaResult = exports.undefinedDeltaMetric = void 0;
+const collectMetric_1 = require("./collectMetric");
+const undefinedDeltaMetric = () => ({
+    kind: 'undefined',
+    value: '~',
+});
+exports.undefinedDeltaMetric = undefinedDeltaMetric;
+function toFlatDeltaResult(deltas) {
+    const out = {
+        header: ['Contract', 'Method'],
+        rows: [],
+    };
+    const contractSet = new Set();
+    const methodMap = new Map();
+    const metricSet = new Set();
+    for (const delta of deltas) {
+        for (const [contract, methods] of Object.entries(delta.result)) {
+            contractSet.add(contract);
+            if (!methodMap.has(contract)) {
+                methodMap.set(contract, new Set());
+            }
+            for (const [method, metrics] of Object.entries(methods)) {
+                methodMap.get(contract).add(method);
+                for (const metric of Object.keys(metrics)) {
+                    metricSet.add(metric);
+                }
+            }
+        }
+    }
+    const metricNames = Array.from(metricSet.values());
+    out.header.push(...Array.from({ length: deltas.length }, () => metricNames).flat());
+    for (const contract of contractSet) {
+        const methods = methodMap.get(contract);
+        for (const method of methods) {
+            const metrics = [];
+            for (const delta of deltas) {
+                for (const metric of metricNames) {
+                    metrics.push(delta.result?.[contract]?.[method]?.[metric] ?? (0, exports.undefinedDeltaMetric)());
+                }
+            }
+            out.rows.push([contract, method, ...metrics]);
+        }
+    }
+    return out;
+}
+exports.toFlatDeltaResult = toFlatDeltaResult;
+const aggregateTarget = ['cells', 'bits', 'gasUsed'];
+const statusTarget = ['success', 'exitCode', 'resultCode'];
+const deltaTarget = [
+    ...aggregateTarget,
+    ...statusTarget,
+    'vmSteps',
+    'totalActions',
+    'skippedActions',
+    'totalActionFees',
+    'data',
+    'code',
+    'state',
+    'message',
+    'in',
+    'out',
+    'execute',
+    'compute',
+    'action',
+];
+/**
+ * Recursively collects the sum of all numeric fields named `needle` within an arbitrary data structure
+ */
+function sumDeep(source, needle) {
+    if (source === null || typeof source !== 'object') {
+        return 0;
+    }
+    if (Array.isArray(source)) {
+        return source.map((item) => sumDeep(item, needle)).reduce((total, current) => total + current, 0);
+    }
+    let total = 0;
+    for (const [key, value] of Object.entries(source)) {
+        if (key === needle && typeof value === 'number') {
+            total += value;
+            continue;
+        }
+        total += sumDeep(value, needle);
+    }
+    return total;
+}
+function aggregatedCompareMetric(before, after, basePath = []) {
+    const out = {};
+    const keys = new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})]);
+    keys.forEach((key) => {
+        if (!deltaTarget.includes(key))
+            return;
+        const prev = before[key];
+        const next = after[key];
+        const path = [...basePath, key];
+        if (prev === undefined || next === undefined)
+            return;
+        if (typeof prev === 'object' && typeof next === 'object') {
+            Object.assign(out, aggregatedCompareMetric(prev, next, path));
+            aggregateTarget.forEach((aggKey) => {
+                const beforeSum = sumDeep(prev, aggKey);
+                const afterSum = sumDeep(next, aggKey);
+                const aggPath = [...path, aggKey].join('.');
+                out[aggPath] = {
+                    kind: beforeSum > afterSum ? 'decrease' : beforeSum < afterSum ? 'increase' : 'same',
+                    path: aggPath,
+                    before: beforeSum,
+                    after: afterSum,
+                };
+            });
+            return;
+        }
+        if (typeof prev === 'number' && typeof next === 'number') {
+            const fullPath = path.join('.');
+            out[fullPath] = {
+                kind: prev > next ? 'decrease' : prev < next ? 'increase' : 'same',
+                path: fullPath,
+                before: prev,
+                after: next,
+            };
+        }
+    });
+    if (basePath.length === 0) {
+        aggregateTarget.forEach((aggKey) => {
+            const beforeSum = sumDeep(before, aggKey);
+            const afterSum = sumDeep(after, aggKey);
+            const rootPath = `root.${aggKey}`;
+            out[rootPath] = {
+                kind: beforeSum > afterSum ? 'decrease' : beforeSum < afterSum ? 'increase' : 'same',
+                path: rootPath,
+                before: beforeSum,
+                after: afterSum,
+            };
+        });
+    }
+    return out;
+}
+exports.aggregatedCompareMetric = aggregatedCompareMetric;
+function prepareItemDelta(item, calcDelta = true) {
+    const out = (0, exports.undefinedDeltaMetric)();
+    if (!item) {
+        return out;
+    }
+    out.kind = calcDelta ? item.kind : 'init';
+    out.value = item.after.toString();
+    if (calcDelta) {
+        let change = item.kind === 'increase' ? ' +' : ' ';
+        if (item.kind === 'same') {
+            change += 'same';
+        }
+        else if (item.before === 0) {
+            change += '100.00%';
+        }
+        else {
+            change += (((item.after - item.before) / item.before) * 100).toFixed(2) + '%';
+        }
+        out.value += change;
+    }
+    return out;
+}
+function prepareDelta(pair) {
+    const result = {};
+    const out = {
+        label: pair.after.label,
+        createdAt: pair.after.createdAt,
+        result,
+    };
+    const beforeMap = new Map();
+    if (pair.before) {
+        for (const b of pair.before.items) {
+            const contractKey = b.contractName || b.address;
+            const methodKey = b.methodName || b.opCode;
+            if (!beforeMap.has(contractKey)) {
+                beforeMap.set(contractKey, new Map());
+            }
+            beforeMap.get(contractKey).set(methodKey, b);
+        }
+    }
+    for (const a of pair.after.items) {
+        const contractKey = a.contractName || a.address;
+        const methodKey = a.methodName || a.opCode;
+        const b = beforeMap.get(contractKey)?.get(methodKey); // может быть undefined
+        const calcDelta = !!b;
+        if (!result[contractKey]) {
+            result[contractKey] = {};
+        }
+        const item = {};
+        result[contractKey][methodKey] = item;
+        const delta = aggregatedCompareMetric(b || a, a);
+        item.gasUsed = prepareItemDelta(delta['execute.compute.gasUsed'], calcDelta);
+        item.cells = prepareItemDelta(delta['state.cells'], calcDelta);
+        item.bits = prepareItemDelta(delta['state.bits'], calcDelta);
+    }
+    return out;
+}
+exports.prepareDelta = prepareDelta;
+function makeGasReport(list) {
+    list = (list || []).sort((0, collectMetric_1.sortByCreatedAt)());
+    const out = [];
+    if (list.length === 0)
+        return out;
+    for (let i = 0; i < list.length; i++) {
+        const after = list[i];
+        const before = i > 0 ? list[i - 1] : undefined;
+        out.push(prepareDelta({ after, before }));
+    }
+    return out;
+}
+exports.makeGasReport = makeGasReport;

package/dist/metric/gasReportTable.d.ts

@@ -0,0 +1,2 @@
+import { ColorDelta, DeltaResult } from './deltaResult';
+export declare function gasReportTable(list: DeltaResult[], color?: ColorDelta): string;

package/dist/metric/gasReportTable.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gasReportTable = void 0;
+const table_1 = require("table");
+const deltaResult_1 = require("./deltaResult");
+const collectMetric_1 = require("./collectMetric");
+const gapCellWidth = 1;
+const maxCellWidth = 25;
+const border = {
+    topBody: '─',
+    topJoin: '┬',
+    topLeft: '┌',
+    topRight: '┐',
+    bottomBody: '─',
+    bottomJoin: '┴',
+    bottomLeft: '└',
+    bottomRight: '┘',
+    bodyLeft: '│',
+    bodyRight: '│',
+    bodyJoin: '│',
+    joinBody: '─',
+    joinLeft: '├',
+    joinRight: '┤',
+    joinJoin: '┼',
+};
+function wrap(value, max) {
+    if (value.length > max) {
+        return `${value.slice(0, max - 3)}...`;
+    }
+    return value;
+}
+function prepareResult(list, color) {
+    list = list.sort((0, collectMetric_1.sortByCreatedAt)(true));
+    const flat = (0, deltaResult_1.toFlatDeltaResult)(list);
+    const rows = [];
+    const widthCols = [];
+    for (const [contract, method, ...values] of flat.rows) {
+        const row = [wrap(contract, maxCellWidth), wrap(method, maxCellWidth)];
+        widthCols[0] = Math.max(widthCols[0] ?? 0, row[0].length);
+        widthCols[1] = Math.max(widthCols[1] ?? 0, row[1].length);
+        values.forEach((metric, idx) => {
+            const value = color ? color(metric) : metric.value;
+            row.push(value);
+            const colIdx = idx + 2;
+            widthCols[colIdx] = Math.max(widthCols[colIdx] ?? 0, metric.value.length);
+        });
+        rows.push(row);
+    }
+    const headers = flat.header;
+    for (let i = 0; i < headers.length; i++) {
+        widthCols[i] = Math.max(widthCols[i] ?? 0, headers[i].length + gapCellWidth);
+    }
+    const groupIndex = {};
+    let current = 0;
+    while (current < rows.length) {
+        const contract = rows[current][0];
+        let count = 1;
+        while (rows[current + count]?.[0] === contract) {
+            count++;
+        }
+        groupIndex[contract] = { index: current, size: count };
+        current += count;
+    }
+    return {
+        labels: list.map((s) => s.label),
+        headers,
+        widthCols,
+        rows,
+        groupIndex,
+    };
+}
+function gasReportTable(list, color) {
+    const result = prepareResult(list, color);
+    if (result.rows.length < 1) {
+        return 'No data available';
+    }
+    const columns = [];
+    for (let i = 0; i < result.headers.length; i++) {
+        columns.push({ alignment: 'center', verticalAlignment: 'middle', width: result.widthCols[i] });
+    }
+    const spanningCells = [
+        { col: 0, row: 0, rowSpan: 2, verticalAlignment: 'middle' },
+        { col: 1, row: 0, rowSpan: 2, verticalAlignment: 'middle' }, // Method title
+    ];
+    for (const group of Object.values(result.groupIndex)) {
+        // rowSpan for Contract name
+        spanningCells.push({ col: 0, row: group.index + 2, rowSpan: group.size, verticalAlignment: 'middle' });
+    }
+    const data = [[], ['', '']];
+    data[0].push(...result.headers.slice(0, 2));
+    data[1].push(...result.headers.slice(2));
+    const metricCount = (result.headers.length - 2) / list.length;
+    let labelTitleOffset = 2;
+    for (const label of result.labels) {
+        spanningCells.push({
+            col: labelTitleOffset,
+            row: 0,
+            colSpan: metricCount,
+            verticalAlignment: 'middle',
+        });
+        labelTitleOffset += metricCount;
+        data[0].push(...[label, ...Array.from({ length: metricCount - 1 }, () => '')]);
+    }
+    data.push(...result.rows);
+    const config = {
+        columns,
+        spanningCells,
+        border,
+    };
+    return (0, table_1.table)(data, config);
+}
+exports.gasReportTable = gasReportTable;

package/dist/metric/index.d.ts

@@ -0,0 +1,6 @@
+export * from './collectMetric';
+export * from './ContractDatabase';
+export * from './defaultColor';
+export * from './deltaResult';
+export * from './gasReportTable';
+export * from './readSnapshots';

package/dist/metric/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./collectMetric"), exports);
+__exportStar(require("./ContractDatabase"), exports);
+__exportStar(require("./defaultColor"), exports);
+__exportStar(require("./deltaResult"), exports);
+__exportStar(require("./gasReportTable"), exports);
+__exportStar(require("./readSnapshots"), exports);

package/dist/metric/readSnapshots.d.ts

@@ -0,0 +1,2 @@
+import { SnapshotMetricList } from './collectMetric';
+export declare function readSnapshots(snapshotDir: string): Promise<SnapshotMetricList>;

package/dist/metric/readSnapshots.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSnapshots = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+async function readSnapshots(snapshotDir) {
+    const list = {};
+    if (!(0, fs_1.existsSync)(snapshotDir)) {
+        return list;
+    }
+    const snapshotFiles = (0, fs_1.readdirSync)(snapshotDir).filter((f) => f.endsWith('.json'));
+    for (const snapshotFile of snapshotFiles) {
+        const data = (0, fs_1.readFileSync)((0, path_1.join)(snapshotDir, snapshotFile), 'utf-8');
+        try {
+            const raw = JSON.parse(data);
+            const snapshot = {
+                ...raw,
+                createdAt: new Date(raw.createdAt),
+            };
+            if (!list[snapshot.label]) {
+                list[snapshot.label] = {
+                    name: snapshotFile,
+                    content: snapshot,
+                };
+            }
+        }
+        catch (_) {
+            throw new Error(`Can not parse snapshot file: ${snapshotFile}`);
+        }
+    }
+    return list;
+}
+exports.readSnapshots = readSnapshots;

package/dist/utils/readJsonl.d.ts

@@ -0,0 +1 @@
+export declare function readJsonl<T>(filePath: string): Promise<T[]>;

package/dist/utils/readJsonl.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonl = void 0;
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+async function readJsonl(filePath) {
+    const input = (0, fs_1.createReadStream)(filePath, { encoding: 'utf8' });
+    const readLine = (0, readline_1.createInterface)({
+        input,
+        crlfDelay: Infinity,
+    });
+    const result = [];
+    for await (const line of readLine) {
+        if (!line.trim())
+            continue;
+        try {
+            result.push(JSON.parse(line));
+        }
+        catch (_) {
+            throw new Error(`Could not parse line: ${line}`);
+        }
+    }
+    return result;
+}
+exports.readJsonl = readJsonl;

package/jest-environment.js

@@ -0,0 +1 @@
+module.exports = require("./dist/jest/BenchmarkEnvironment").default;

package/jest-reporter.js

@@ -0,0 +1 @@
+module.exports = require("./dist/jest/BenchmarkReporter").default;

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@ton/sandbox",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "TON transaction emulator",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "TonTech",
   "files": [
+    "jest-environment.js",
+    "jest-reporter.js",
     "dist/**/*"
   ],
   "repository": {
@@ -20,19 +22,31 @@
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
     "jest": "^29.5.0",
+    "jest-config": "^29.7.0",
+    "jest-environment-node": "^29.7.0",
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.5"
   },
   "peerDependencies": {
-    "@ton/crypto": ">=3.3.0"
+    "@ton/crypto": ">=3.3.0",
+    "jest": "^29.5.0"
+  },
+  "peerDependenciesMeta": {
+    "jest": {
+      "optional": true
+    }
   },
   "scripts": {
+    "metric": "BENCH_NEW=\"@ton/sandbox v$(npm view @ton/sandbox version)\" jest",
     "wasm:pack": "ts-node ./scripts/pack-wasm.ts",
     "wasm:copy": "cp src/executor/emulator-emscripten.js src/executor/emulator-emscripten.wasm.js ./dist/executor",
     "test": "yarn wasm:pack && yarn jest src",
-    "build": "rm -rf dist && yarn wasm:pack && yarn test && tsc && yarn wasm:copy",
+    "build": "rm -rf dist && yarn wasm:pack && tsc && yarn test && yarn wasm:copy",
     "config:pack": "ts-node ./scripts/pack-config.ts"
   },
-  "packageManager": "yarn@3.6.1"
+  "packageManager": "yarn@3.6.1",
+  "dependencies": {
+    "table": "^6.9.0"
+  }
 }