@ton/sandbox 0.30.0 → 0.32.0

package/dist/index.d.ts

@@ -4,10 +4,11 @@ export { BlockchainContractProvider, SandboxContractProvider, } from './blockcha
 export { BlockchainSender, } from './blockchain/BlockchainSender';
 export { BlockchainStorage, LocalBlockchainStorage, RemoteBlockchainStorage, RemoteBlockchainStorageClient, wrapTonClient4ForRemote, } from './blockchain/BlockchainStorage';
 export { Verbosity, LogsVerbosity, SmartContract, SmartContractTransaction, MessageParams, GetMethodParams, GetMethodResult, createEmptyShardAccount, createShardAccount, GetMethodError, TimeError, SmartContractSnapshot, EmulationError, } from './blockchain/SmartContract';
-export { TickOrTock, IExecutor, Executor, GetMethodArgs as ExecutorGetMethodArgs, GetMethodResult as ExecutorGetMethodResult, RunTickTockArgs as ExecutorRunTickTockArgs, EmulationResult as ExecutorEmulationResult, RunTransactionArgs as ExecutorRunTransactionArgs, ExecutorVerbosity, } from './executor/Executor';
+export { TickOrTock, IExecutor, Executor, GetMethodArgs as ExecutorGetMethodArgs, GetMethodResult as ExecutorGetMethodResult, RunTickTockArgs as ExecutorRunTickTockArgs, EmulationResult as ExecutorEmulationResult, RunTransactionArgs as ExecutorRunTransactionArgs, ExecutorVerbosity, BlockId, PrevBlocksInfo, } from './executor/Executor';
 export { Event, EventAccountCreated, EventAccountDestroyed, EventMessageSent, } from './event/Event';
 export { Treasury, TreasuryContract, } from './treasury/Treasury';
 export { prettyLogTransaction, prettyLogTransactions, } from './utils/prettyLogTransaction';
 export { printTransactionFees, } from './utils/printTransactionFees';
 export { internal, } from './utils/message';
 export { ExtraCurrency, } from './utils/ec';
+export * from './metric';

package/dist/index.js

@@ -1,4 +1,18 @@
 "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 });
 exports.internal = exports.printTransactionFees = exports.prettyLogTransactions = exports.prettyLogTransaction = exports.TreasuryContract = exports.Executor = exports.EmulationError = exports.TimeError = exports.GetMethodError = exports.createShardAccount = exports.createEmptyShardAccount = exports.SmartContract = exports.wrapTonClient4ForRemote = exports.RemoteBlockchainStorage = exports.LocalBlockchainStorage = exports.BlockchainSender = exports.BlockchainContractProvider = exports.toSandboxContract = exports.Blockchain = exports.defaultConfigSeqno = exports.defaultConfig = void 0;
 var defaultConfig_1 = require("./config/defaultConfig");
@@ -33,3 +47,4 @@ var printTransactionFees_1 = require("./utils/printTransactionFees");
 Object.defineProperty(exports, "printTransactionFees", { enumerable: true, get: function () { return printTransactionFees_1.printTransactionFees; } });
 var message_1 = require("./utils/message");
 Object.defineProperty(exports, "internal", { enumerable: true, get: function () { return message_1.internal; } });
+__exportStar(require("./metric"), exports);

package/dist/jest/BenchmarkCommand.d.ts

@@ -0,0 +1,10 @@
+export interface BenchmarkCommandOption {
+    label: string;
+    doDiff: boolean;
+}
+export declare class BenchmarkCommand {
+    readonly label?: string;
+    readonly doDiff: boolean;
+    constructor(option?: Partial<BenchmarkCommandOption>);
+    get doBenchmark(): boolean;
+}

package/dist/jest/BenchmarkCommand.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkCommand = void 0;
+class BenchmarkCommand {
+    constructor(option) {
+        option = option || {};
+        this.label = option?.label ?? process.env?.BENCH_NEW;
+        this.doDiff = option?.doDiff ?? process.env?.BENCH_DIFF === 'true' ?? false;
+    }
+    get doBenchmark() {
+        return this.doDiff || typeof this.label !== 'undefined';
+    }
+}
+exports.BenchmarkCommand = BenchmarkCommand;

package/dist/jest/BenchmarkEnvironment.d.ts

@@ -0,0 +1,19 @@
+import type { EnvironmentContext } from '@jest/environment';
+import NodeEnvironment from 'jest-environment-node';
+import { Config } from '@jest/types';
+import { BenchmarkCommand, BenchmarkCommandOption } from './BenchmarkCommand';
+export declare const sandboxMetricRawFile = ".sandbox-metric-raw.jsonl";
+export type BenchmarkEnvironmentConfig = {
+    projectConfig: Config.ProjectConfig & {
+        testEnvironmentCommand?: Partial<BenchmarkCommandOption>;
+    };
+    globalConfig: Config.GlobalConfig;
+};
+export default class BenchmarkEnvironment extends NodeEnvironment {
+    protected command: BenchmarkCommand;
+    protected rootDir: string;
+    constructor(config: BenchmarkEnvironmentConfig, context: EnvironmentContext);
+    setup(): Promise<void>;
+    get resultFile(): string;
+    teardown(): Promise<void>;
+}

package/dist/jest/BenchmarkEnvironment.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxMetricRawFile = void 0;
+const path_1 = require("path");
+const node_fs_1 = require("node:fs");
+const jest_environment_node_1 = __importDefault(require("jest-environment-node"));
+const BenchmarkCommand_1 = require("./BenchmarkCommand");
+const metric_1 = require("../metric");
+exports.sandboxMetricRawFile = '.sandbox-metric-raw.jsonl';
+class BenchmarkEnvironment extends jest_environment_node_1.default {
+    constructor(config, context) {
+        super(config, context);
+        this.command = new BenchmarkCommand_1.BenchmarkCommand(config.projectConfig.testEnvironmentCommand);
+        this.rootDir = config.globalConfig.rootDir;
+    }
+    async setup() {
+        if (this.command.doBenchmark) {
+            (0, metric_1.createMetricStore)(this.global);
+        }
+    }
+    get resultFile() {
+        return (0, path_1.join)(this.rootDir, exports.sandboxMetricRawFile);
+    }
+    async teardown() {
+        if (this.command.doBenchmark) {
+            const store = (0, metric_1.getMetricStore)(this.global) || [];
+            const fileName = this.resultFile;
+            const folder = (0, path_1.dirname)(fileName);
+            if (!(0, node_fs_1.existsSync)(folder)) {
+                (0, node_fs_1.mkdirSync)(folder, { recursive: true });
+            }
+            if (!(0, node_fs_1.existsSync)(fileName)) {
+                (0, node_fs_1.writeFileSync)(fileName, '');
+            }
+            for (const item of store) {
+                (0, node_fs_1.appendFileSync)(fileName, JSON.stringify(item) + '\n');
+            }
+            (0, metric_1.resetMetricStore)(this.global);
+        }
+        await super.teardown();
+    }
+}
+exports.default = BenchmarkEnvironment;

package/dist/jest/BenchmarkReporter.d.ts

@@ -0,0 +1,45 @@
+import { BaseReporter } from '@jest/reporters';
+import type { Config } from '@jest/types';
+import { ContractABI } from '@ton/core';
+import { BenchmarkCommand } from './BenchmarkCommand';
+import { Metric, CodeHash, SnapshotMetric, ContractDatabase } from '../metric';
+export declare const defaultSnapshotDir = ".snapshot";
+export declare const defaultReportName = "gas-report";
+export declare const defaultContractDatabaseName = "contract.abi.json";
+export declare const defaultDepthCompare = 2;
+export declare const minComparisonDepth = 1;
+type ReportMode = 'gas' | 'average';
+export interface Options {
+    reportMode?: ReportMode;
+    reportName?: string;
+    snapshotDir?: string;
+    depthCompare?: number;
+    contractExcludes?: string[];
+    removeRawResult?: boolean;
+    contractDatabase?: Record<CodeHash, ContractABI> | string;
+}
+export default class BenchmarkReporter extends BaseReporter {
+    protected rootDirPath: string;
+    protected options: Options;
+    protected command: BenchmarkCommand;
+    contractDatabase: ContractDatabase;
+    constructor(globalConfig: Config.GlobalConfig, options?: Options);
+    get reportMode(): ReportMode;
+    get reportName(): string;
+    get snapshotDir(): string;
+    get snapshotDirPath(): string;
+    get depthCompare(): number;
+    get snapshotFiles(): Promise<import("../metric").SnapshotMetricList>;
+    get snapshots(): Promise<SnapshotMetric[]>;
+    get snapshotCurrent(): Promise<SnapshotMetric>;
+    get removeRawResult(): true;
+    get contractExcludes(): string[];
+    get sandboxMetricRawFile(): string;
+    get metricStore(): Promise<Metric[]>;
+    readContractDatabase(): ContractDatabase;
+    saveContractDatabase(): void;
+    onRunComplete(): Promise<void>;
+    gasReportReport(data: SnapshotMetric[], benchmarkDepth: number): string[];
+    saveSnapshot(label: string): Promise<string>;
+}
+export {};

package/dist/jest/BenchmarkReporter.js

@@ -0,0 +1,207 @@
+"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.minComparisonDepth = exports.defaultDepthCompare = exports.defaultContractDatabaseName = exports.defaultReportName = exports.defaultSnapshotDir = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const chalk_1 = __importStar(require("chalk"));
+const reporters_1 = require("@jest/reporters");
+const BenchmarkCommand_1 = require("./BenchmarkCommand");
+const BenchmarkEnvironment_1 = require("./BenchmarkEnvironment");
+const readJsonl_1 = require("../utils/readJsonl");
+const metric_1 = require("../metric");
+exports.defaultSnapshotDir = '.snapshot';
+exports.defaultReportName = 'gas-report';
+exports.defaultContractDatabaseName = 'contract.abi.json';
+exports.defaultDepthCompare = 2;
+exports.minComparisonDepth = 1;
+const PASS_TEXT = 'PASS';
+const PASS = chalk_1.supportsColor ? chalk_1.default.reset.inverse.bold.green(` ${PASS_TEXT} `) : PASS_TEXT;
+const SKIP_TEXT = 'SKIP';
+const SKIP = chalk_1.supportsColor ? chalk_1.default.reset.inverse.bold.yellow(` ${SKIP_TEXT} `) : SKIP_TEXT;
+class BenchmarkReporter extends reporters_1.BaseReporter {
+    constructor(globalConfig, options = {}) {
+        super();
+        this.rootDirPath = globalConfig.rootDir;
+        this.options = options;
+        this.command = new BenchmarkCommand_1.BenchmarkCommand();
+        if (this.depthCompare < exports.minComparisonDepth) {
+            throw new Error(`The minimum depth compare must be greater than or equal to ${exports.minComparisonDepth}`);
+        }
+        this.contractDatabase = this.readContractDatabase();
+    }
+    get reportMode() {
+        return this.options.reportMode || 'gas';
+    }
+    get reportName() {
+        return this.options.reportName || exports.defaultReportName;
+    }
+    get snapshotDir() {
+        return this.options.snapshotDir || exports.defaultSnapshotDir;
+    }
+    get snapshotDirPath() {
+        const dirPath = (0, path_1.join)(this.rootDirPath, this.snapshotDir);
+        try {
+            if (!(0, fs_1.existsSync)(dirPath)) {
+                (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+            }
+        }
+        catch (_) {
+            throw new Error(`Can not create directory: ${dirPath}`);
+        }
+        return dirPath;
+    }
+    get depthCompare() {
+        return this.options.depthCompare || exports.defaultDepthCompare;
+    }
+    get snapshotFiles() {
+        return (0, metric_1.readSnapshots)(this.snapshotDirPath);
+    }
+    get snapshots() {
+        return this.snapshotFiles.then((list) => Object.values(list).map((item) => item.content));
+    }
+    get snapshotCurrent() {
+        return this.metricStore.then((store) => (0, metric_1.makeSnapshotMetric)(store, {
+            contractDatabase: this.contractDatabase,
+            contractExcludes: this.contractExcludes,
+        }));
+    }
+    get removeRawResult() {
+        return this.options.removeRawResult || true;
+    }
+    get contractExcludes() {
+        return this.options.contractExcludes || [];
+    }
+    get sandboxMetricRawFile() {
+        return (0, path_1.join)(this.rootDirPath, BenchmarkEnvironment_1.sandboxMetricRawFile);
+    }
+    get metricStore() {
+        if ((0, fs_1.existsSync)(this.sandboxMetricRawFile)) {
+            return (0, readJsonl_1.readJsonl)(this.sandboxMetricRawFile);
+        }
+        return new Promise((resolve) => resolve([]));
+    }
+    readContractDatabase() {
+        let data = {};
+        const filePath = this.options.contractDatabase || exports.defaultContractDatabaseName;
+        if (typeof filePath === 'string') {
+            try {
+                if ((0, fs_1.existsSync)((0, path_1.join)(this.rootDirPath, filePath))) {
+                    data = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(this.rootDirPath, filePath), 'utf-8'));
+                }
+            }
+            catch (error) {
+                throw new Error(`Could not parse contract database: ${filePath}`);
+            }
+        }
+        return metric_1.ContractDatabase.from(data);
+    }
+    saveContractDatabase() {
+        const contractDatabase = this.options.contractDatabase;
+        let filePath = typeof contractDatabase === 'string' ? contractDatabase : exports.defaultContractDatabaseName;
+        try {
+            const content = JSON.stringify(this.contractDatabase.data, null, 2) + '\n';
+            (0, fs_1.writeFileSync)((0, path_1.join)(this.rootDirPath, filePath), content, {
+                encoding: 'utf8',
+            });
+        }
+        catch (_) {
+            throw new Error(`Can not write: ${filePath}`);
+        }
+    }
+    async onRunComplete() {
+        const log = [];
+        let status = SKIP;
+        if (this.command.doBenchmark) {
+            const list = await this.snapshots;
+            const snapshots = [await this.snapshotCurrent, ...list];
+            let doDiff = this.command.doDiff;
+            const depthCompare = Math.min(snapshots.length, this.depthCompare);
+            if (doDiff) {
+                log.push(`Comparison metric mode: ${this.reportMode} depth: ${depthCompare}`);
+                switch (this.reportMode) {
+                    case 'gas':
+                        log.push(...this.gasReportReport(snapshots, depthCompare));
+                        status = PASS;
+                        break;
+                    default:
+                        throw new Error(`Report mode ${this.reportMode} not supported`);
+                }
+            }
+            else if (this.command.label) {
+                log.push(`Collect metric mode: "${this.reportMode}"`);
+                const file = await this.saveSnapshot(this.command.label);
+                log.push(`Report write in '${file}'`);
+                status = PASS;
+            }
+            if (this.removeRawResult) {
+                (0, fs_1.unlinkSync)(this.sandboxMetricRawFile);
+            }
+            this.saveContractDatabase();
+        }
+        else {
+            log.push(`Reporter mode: ${this.reportMode}`);
+        }
+        this.log(`${status} ${log.join('\n')}`);
+    }
+    gasReportReport(data, benchmarkDepth) {
+        const log = [];
+        const reportFile = `${this.reportName}.json`;
+        const report = (0, metric_1.makeGasReport)(data);
+        try {
+            const reportFilePath = (0, path_1.join)(this.rootDirPath, reportFile);
+            (0, fs_1.writeFileSync)(reportFilePath, JSON.stringify(report, null, 2) + '\n', {
+                encoding: 'utf8',
+            });
+            log.push(`Gas report write in '${reportFile}'`);
+        }
+        catch (_) {
+            throw new Error(`Can not write: ${reportFile}`);
+        }
+        const list = report.sort((0, metric_1.sortByCreatedAt)(true)).slice(0, benchmarkDepth);
+        log.push((0, metric_1.gasReportTable)(list, metric_1.defaultColor));
+        return log;
+    }
+    async saveSnapshot(label) {
+        const snapshot = await this.snapshotCurrent;
+        snapshot.label = label;
+        const list = await this.snapshotFiles;
+        let snapshotFile = `${snapshot.createdAt.getTime()}.json`;
+        if (list[snapshot.label]) {
+            snapshotFile = list[snapshot.label].name;
+        }
+        const snapshotFilePath = (0, path_1.join)(this.snapshotDirPath, snapshotFile);
+        try {
+            (0, fs_1.writeFileSync)(snapshotFilePath, JSON.stringify(snapshot, null, 2) + '\n', {
+                encoding: 'utf8',
+            });
+        }
+        catch (_) {
+            throw new Error(`Can not write: ${(0, path_1.join)(this.snapshotDir, snapshotFile)}`);
+        }
+        return (0, path_1.join)(this.snapshotDir, snapshotFile);
+    }
+}
+exports.default = BenchmarkReporter;

package/dist/meta/ContractsMeta.d.ts

@@ -0,0 +1,10 @@
+import { Address, ContractABI } from "@ton/core";
+export type ContractMeta = {
+    wrapperName?: string;
+    abi?: ContractABI | null;
+    treasurySeed?: string;
+};
+export interface ContractsMeta {
+    get(key: Address): ContractMeta | undefined;
+    upsert(key: Address, value: Partial<ContractMeta>): void;
+}

package/dist/meta/ContractsMeta.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/metric/ContractDatabase.d.ts

@@ -0,0 +1,21 @@
+import { ContractABI } from '@ton/core';
+import { CodeHash, Metric, OpCode } from './collectMetric';
+type Condition = {
+    codeHash: CodeHash;
+    opCode: OpCode;
+    receiver: 'internal' | 'external-in' | 'external-out';
+};
+export type ContractDataKey = CodeHash | string;
+export type ContractData = Record<ContractDataKey, ContractABI | ContractDataKey>;
+export declare class ContractDatabase {
+    protected list: Map<ContractDataKey, ContractABI>;
+    protected match: Map<ContractDataKey, ContractDataKey>;
+    constructor(abiList: Map<ContractDataKey, ContractABI>, codeHashMatch: Map<ContractDataKey, ContractDataKey>);
+    static from(data: ContractData): ContractDatabase;
+    get data(): ContractData;
+    origin(needle: ContractDataKey): string;
+    get(needle: ContractDataKey): ContractABI | undefined;
+    extract(metric: Metric): void;
+    by(where: Partial<Condition>): Partial<Metric>;
+}
+export {};

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