@ton/sandbox 0.30.0 → 0.32.0

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>;

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>;