@ton/sandbox 0.11.0

package/CHANGELOG.md

@@ -0,0 +1,221 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.11.0] - 2023-05-11
+
+### Added
+
+- Added the ability to emulate ticktock transactions. There are 3 ways to do that: `blockchain.runTickTock(Address | Address[], TickOrTock, MessageParams?)`, `smartContract.runTickTock(TickOrTock, MessageParams?)`, or you can change `ContractProvider` in your wrapper classes to be `SandboxContractProvider` and invoke `tickTock(TickOrTock)` on it. `TickOrTock` is a union type `'tick' | 'tock'`
+- Added new verbosity levels: `'vm_logs_location'` (same as `'vm_logs'` but also display code cell hash and offset), `'vm_logs_gas'` (same as `'vm_logs_location'` but also display gas remaining), `'vm_logs_verbose'` (same as `'vm_logs_full'` but display stack values in a more verbose way)
+
+### Changed
+
+- Changed emulator WASM binary
+
+## [0.10.0] - 2023-05-04
+
+### Changed
+
+- Changed emulator WASM binary
+- Changed treasury code
+
+### Fixed
+
+- Fixed certain interactions between snapshots and treasuries
+
+## [0.9.0] - 2023-04-27
+
+### Added
+
+- Added `printTransactionFees` helper for easier calculation of fees of different operations
+- Added `blockchain.snapshot`, `blockchain.loadFrom`, `smartContract.snapshot`, `smartContract.loadFrom` methods to create state snapshots of the respective objects and restore from them at a later point in time. They return and accept new types, `BlockchainSnapshot` and `SmartContractSnapshot`
+
+## [0.8.0] - 2023-04-07
+
+This release contains a breaking change.
+
+### Added
+
+- Added `blockchain.createWallets` method which accepts a number `n` and optional `TreasuryParams`. It creates `n` treasuries and returns them as an array
+
+### Changed
+
+- `RemoteBlockchainStorage` now requires a `RemoteBlockchainStorageClient` instead of `TonClient4`. There is a helper function, `wrapTonClient4ForRemote`, to wrap a `TonClient4` into `RemoteBlockchainStorageClient`. This is a breaking change
+- Updated default config
+- `Blockchain.create` now accepts an optional `BlockchainConfig = Cell | 'default' | 'slim'` as the config. If nothing or `'default'` is specified, the default config is used, if `'slim'` is specified, the slim config is used (it is much smaller than the default config, which improves performance), if a `Cell` is passed, then it is used as the config
+
+### Removed
+
+- Removed ton as a peer dependency
+
+## [0.7.0] - 2023-03-27
+
+### Added
+
+- Added `externals: ExternalOut[]` field to `BlockchainTransaction` and `SendMessageResult`. `ExternalOut` is a specialized type for external out messages compatible with `Message` from ton-core
+
+### Changed
+
+- Get methods now throw a specialized error type `GetMethodError` when exit code is not 0
+- Smart contracts now throw a specialized error type `TimeError` when trying to run a transaction at a unix timestamp that is less than the unix timestamp of the last transaction
+- Get methods now return `gasUsed` and `logs` from the `ContractProvider` on opened contracts
+
+### Other
+
+- Consecutive transaction emulations have been optimized
+
+## [0.6.1] - 2023-03-16
+
+### Fixed
+
+- Fixed `blockchain.now` override for get methods in opened contracts
+
+## [0.6.0] - 2023-03-13
+
+### Added
+
+- Added `treasury.getBalance` method
+- Added `blockchain.now` getter and setter to override current unix time as seen during contract execution (both transactions and get methods). Note that this is unix timestamp, not JS timestamp, so you need to use `Math.floor(Date.now() / 1000)` instead of `Date.now()` to set current time
+
+### Changed
+
+- `RemoteBlockchainStorage` constructor now accepts a second optional parameter, `blockSeqno?: number`. If passed, all accounts will be pulled from that block number instead of the latest one
+
+## [0.5.1] - 2023-03-02
+
+### Changed
+
+- Changed ton and ton-core dev and peer dependencies to versions 13.4.1 and 0.48.0 respectively
+
+### Fixed
+
+- Fixed typos in `SendMode.PAY_GAS_SEPARATLY` (missing E) from ton-core
+
+## [0.5.0] - 2023-02-22
+
+This release contains multiple breaking changes.
+
+### Added
+
+- Added `blockchain.libs: Cell | undefined` getter and setter for global libraries dictionary (as a `Cell`)
+
+### Changed
+
+- `blockchain.treasury` now accepts an optional `TreasuryParams` argument (see below for definition) instead of the old optional `workchain?: number` argument. This is a breaking change
+```typescript
+export type TreasuryParams = Partial<{
+    workchain: number
+    predeploy: boolean
+    balance: bigint
+    resetBalanceIfZero: boolean
+}>
+```
+- `OpenedContract` was renamed to `SandboxContract`. This is a breaking change
+- `LogsVerbosity` now has a new field, `print: boolean` (defaults to `true` on the `Blockchain` instance), which controls whether to `console.log` any logs at all (both from transactions and get methods). This is a breaking change
+- `smartContract.get` and `blockchain.runGetMethod` now return `GetMethodResult` (see below for definition). The differences from the previous return type are as follows:
+    - `logs` renamed to `vmLogs`. This is a breaking change
+    - `gasUsed` is now of type `bigint`. This is a breaking change
+    - `blockchainLogs: string` and `debugLogs: string` were added
+```typescript
+export type GetMethodResult = {
+    stack: TupleItem[]
+    stackReader: TupleReader
+    exitCode: number
+    gasUsed: bigint
+    blockchainLogs: string
+    vmLogs: string
+    debugLogs: string
+}
+```
+- Properties `storage` and `messageQueue` on `Blockchain` are now protected. This is a breaking change
+- All properties and methods of `Blockchain` that were private are now protected to improve extensibility. Note that any invariants expected by `Blockchain` must be upheld
+- `blockchain.sendMessage` and `smartContract.receiveMessage` now accept an optional `MessageParams` argument (see below for definition). These parameters are used for every transaction in the chain in case of `blockchain.sendMessage`
+```typescript
+export type MessageParams = Partial<{
+    now: number
+    randomSeed: Buffer
+    ignoreChksig: boolean
+}>
+```
+- `blockchain.runGetMethod` and `smartContract.get` now accept an optional `GetMethodParams` argument (see below for definition)
+```typescript
+export type GetMethodParams = Partial<{
+    now: number
+    randomSeed: Buffer
+    gasLimit: bigint
+}>
+```
+- `SendMessageResult` now has `transactions: BlockchainTransaction[]` instead of `transactions: Transaction[]`. Definition of `BlockchainTransaction`:
+```typescript
+export type BlockchainTransaction = Transaction & {
+    blockchainLogs: string
+    vmLogs: string
+    debugLogs: string
+    events: Event[]
+    parent?: BlockchainTransaction
+    children: BlockchainTransaction[]
+}
+```
+- `smartContract.receiveMessage` now returns `SmartContractTransaction` (see below for definition)
+```typescript
+export type SmartContractTransaction = Transaction & {
+    blockchainLogs: string
+    vmLogs: string
+    debugLogs: string
+}
+```
+- Emulator WASM binary has been updated
+
+### Fixed
+
+- Fixed empty message bodies in bounced messages. This fix is contained in the emulator WASM binary
+
+## [0.4.0] - 2023-02-09
+
+### Changed
+
+- Treasuries obtained by `blockchain.treasury` calls are now initialized during this call and will no longer produce an extra transaction when first sending a message
+- Transaction processing loop now prefetches contracts, which should provide a performance boost in some scenarios
+
+## [0.3.0] - 2023-02-05
+
+### Changed
+
+- `Blockchain` and `SmartContract` now use `LogsVerbosity` (see below for definition) as the verbosity type, which allows for more control over what kinds of logs are printed. Logs from TVM debug primitives are now enabled by default, again. (You can disable them globally by setting verbosity with `debugLogs: false` on the `Blockchain` instance)
+
+Definition of `LogsVerbosity`:
+```typescript
+type LogsVerbosity = {
+    blockchainLogs: boolean
+    vmLogs: Verbosity
+    debugLogs: boolean
+}
+```
+
+## [0.2.2] - 2023-02-03
+
+### Added 
+
+- Added `blockchain.runGetMethod(address, method, stack)` to run a get method on the specified address
+- Added `blockchain.setShardAccount(address, account)` to directly set the state of smart contracts
+- Added `account: ShardAccount` getter and setter to `SmartContract`
+- Exported helper methods `createEmptyShardAccount`, `createShardAccount` for use with `blockchain.setShardAccount` and `smartContract.account` setter
+- Added the ability to pass `Cell`s into `blockchain.sendMessage`
+
+### Changed
+
+- Removed unnecessary `async` modifiers from `smartContract.receiveMessage` and `smartContract.get`
+- Logs from TVM debug primitives (for example, `DUMP` and `STRDUMP` with corresponding FunC functions `~dump()` and `~strdump()`) now respect the `verbosity` parameter and will only work when it is not `none`
+- Logs from TVM debug primitives are now printed using a single `console.log` call per one TVM execution to avoid cluttering the terminal during unit tests
+
+### Fixed
+
+- Fixed potential race conditions between execution of different transaction chains on the same `Blockchain` instance by use of an `AsyncLock`
+
+### Removed
+
+- Changed `blockchain.pushMessage`, `blockchain.processQueue`, `blockchain.runQueue` to be private

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ton Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,214 @@
+# Sandbox
+
+This package allows you to emulate arbitrary TON smart contracts, send messages to them and run get methods on them as if they were deployed on a real network.
+
+The key difference of this package from [ton-contract-executor](https://github.com/ton-community/ton-contract-executor) is the fact that the latter only emulates the compute phase of the contract - it does not know about any other phases and thus does not know anything about fees and balances (in a sense that it does not know whether a contract's balance will be enough to process all the out messages that it produces). On the other hand, this package emulates all the phases of a contract, and as a result, the emulation is much closer to what would happen in a real network.
+
+## Installation
+
+Requires node 16 or higher.
+
+```
+yarn add @ton/sandbox ton @ton/core ton-crypto
+```
+or
+```
+npm i @ton/sandbox ton @ton/core ton-crypto
+```
+
+## Usage
+
+To use this package, you need to create an instance of the `Blockchain` class using the static method `Blockchain.create` as follows:
+```typescript
+import { Blockchain } from "@ton/sandbox";
+
+const blockchain = await Blockchain.create()
+```
+
+After that, you can use the low level methods on Blockchain (such as sendMessage) to emulate any messages that you want, but the recommended way to use it is to write wrappers for your contract using the `Contract` interface from `ton-core`. Then you can use `blockchain.openContract` on instances of such contracts, and they will be wrapped in a Proxy that will supply a `ContractProvider` as a first argument to all its methods starting with either `get` or `send`. Also all `send` methods will get Promisified and will return results of running the blockchain message queue along with the original method's result in the `result` field.
+
+A good example of this is the [treasury contract](/src/treasury/Treasury.ts) that is basically a built-in highload wallet meant to help you write tests for your systems of smart contracts. When `blockchain.treasury` is called, an instance of `TreasuryContract` is created and `blockchain.openContract` is called to "open" it. After that, when you call `treasury.send`, `Blockchain` automatically supplies the first `provider` argument.
+
+For your own contracts, you can draw inspiration from the contracts in the [examples](/examples/) - all of them use the `provider.internal` method to send internal messages using the treasuries passed in from the unit test file.
+Here is an excerpt of that from [NftItem.ts](/examples/contracts/NftItem.ts):
+```typescript
+import { Address, beginCell, Cell, Contract, ContractProvider, Sender, toNano, Builder } from "ton-core";
+
+class NftItem implements Contract {
+    async sendTransfer(provider: ContractProvider, via: Sender, params: {
+        value?: bigint
+        to: Address
+        responseTo?: Address
+        forwardAmount?: bigint
+        forwardBody?: Cell | Builder
+    }) {
+        await provider.internal(via, {
+            value: params.value ?? toNano('0.05'),
+            body: beginCell()
+                .storeUint(0x5fcc3d14, 32) // op
+                .storeUint(0, 64) // query id
+                .storeAddress(params.to)
+                .storeAddress(params.responseTo)
+                .storeBit(false) // custom payload
+                .storeCoins(params.forwardAmount ?? 0n)
+                .storeMaybeRef(params.forwardBody)
+                .endCell()
+        })
+    }
+}
+```
+
+When you call `nftItem.sendTransfer(treasury.getSender(), { to: recipient })` (with `nftItem` being an "opened" instance of `NftItem`), an external message to the wallet represented by `treasury` will be pushed onto the message queue, then processed, generating an internal message to the NFT contract.
+
+Here is another excerpt that shows the way to interact with get methods from wrappers:
+```typescript
+import { Contract, ContractProvider } from "ton-core";
+
+export type NftItemData = {
+    inited: boolean
+    index: number
+    collection: Address | null
+    owner: Address | null
+    content: Cell | null
+}
+
+class NftItem implements Contract {
+    async getData(provider: ContractProvider): Promise<NftItemData> {
+        const { stack } = await provider.get('get_nft_data', [])
+        return {
+            inited: stack.readBoolean(),
+            index: stack.readNumber(),
+            collection: stack.readAddressOpt(),
+            owner: stack.readAddressOpt(),
+            content: stack.readCellOpt(),
+        }
+    }
+}
+```
+
+When you call `nftItem.getData()` (note that just like in the `sendTransfer` method, you don't need to supply the `provider` argument - it's done for you on "opened" instances), the `provider` will query the smart contract contained in blockchain and parse the data according to the code. Note that unlike the `send` methods, `get` methods on "opened" instances will return the original result as-is to the caller.
+
+Notes:
+- All of the methods of contracts that you want to "open" that start with `get` or `send` **NEED** to accept `provider: ContractProvider` as a first argument (even if not used) due to how the wrapper works.
+- You can open any contract at any address, even if it is not yet deployed or was deployed by a "parent" opened contract. The only requirement is that the `address` field (required by the `Contract` interface) is the address of the contract that you want to open, and that `init` is present if you want to deploy using methods on the opened instance (in other cases, `init` is not necessary).
+- Ideally, at most one call to **either** `provider.internal` or `provider.external` should be made within a `send` method. Otherwise, you may get hard to interpret (but generally speaking correct) results.
+- No calls to `provider.external` or `provider.internal` should be made within `get` methods. Otherwise, you will get weird and wrong results in the following `send` methods of any contract.
+
+## Writing tests
+
+You can install additional `@ton/test-utils` package by running `yarn add @ton/test-utils -D` or `npm i --save-dev @ton/test-utils` (with `.toHaveTransaction` for jest or `.transaction` or `.to.have.transaction` for chai matcher) to add additional helpers for ease of testing. Don't forget to import them in your unit test files though!
+
+Here is an excerpt of how it's used in the NFT collection example mentioned above:
+```typescript
+const buyResult = await buyer.send({
+    to: sale.address,
+    value: price + toNano('1'),
+    sendMode: SendMode.PAY_GAS_SEPARATELY,
+})
+
+expect(buyResult.transactions).toHaveTransaction({
+    from: sale.address,
+    to: marketplace.address,
+    value: fee,
+})
+expect(buyResult.transactions).toHaveTransaction({
+    from: sale.address,
+    to: collection.address,
+    value: fee,
+})
+```
+(in that example `jest` is used)
+
+The matcher supports the following fields:
+```typescript
+export type FlatTransaction = {
+    from?: Address
+    to: Address
+    value?: bigint
+    body: Cell
+    initData?: Cell
+    initCode?: Cell
+    deploy: boolean
+    lt: bigint
+    now: number
+    outMessagesCount: number
+    oldStatus: AccountStatus
+    endStatus: AccountStatus
+    totalFees?: bigint
+    aborted?: boolean
+    destroyed?: boolean
+    exitCode?: number
+    success?: boolean
+}
+```
+
+But you can omit those you're not interested in, and you can also pass in functions accepting those types returning booleans (`true` meaning good) to check for example number ranges, message opcodes, etc. Note however that if a field is optional (like `from?: Address`), then the function needs to accept the optional type, too.
+
+### Viewing logs
+
+`Blockchain` and `SmartContract` use `LogsVerbosity` to determine what kinds of logs to print. Here is the definition:
+```typescript
+type LogsVerbosity = {
+    print: boolean
+    blockchainLogs: boolean
+    vmLogs: Verbosity
+    debugLogs: boolean
+}
+
+type Verbosity = 'none' | 'vm_logs' | 'vm_logs_full'
+```
+
+Setting verbosity on `SmartContract`s works like an override with respect to what is set on `Blockchain`.
+
+`debugLogs` is enabled by default on the `Blockchain` instance (so every `SmartContract` that does not have `debugLogs` overridden will print debug logs), other kinds of logs are turned off.
+
+`print` determines whether to `console.log` all the non-empty logs (if set to `false`, logs will be collected but will only be exposed in the return values of methods on `Blockchain` and `SmartContract`, and not printed to console), defaults to `true` on the `Blockchain` instance.
+
+`'vm_logs'` prints the log of every instruction that was executed, `'vm_logs_full'` also includes code cell hashes, locations, and stack information for every instruction executed.
+
+To override verbosity on a specific contract, use `await blockchain.setVerbosityForAddress(targetAddress, verbosity)`, for example:
+```typescript
+await blockchain.setVerbosityForAddress(targetAddress, {
+    blockchainLogs: true,
+    vmLogs: 'vm_logs',
+})
+```
+After that, the target contract will be using `debugLogs` from the `Blockchain` instance to determine whether to print debug logs, but will always print VM logs and blockchain logs.
+
+To set global verbosity, use the `blockchain.verbosity` setter, for example:
+```typescript
+blockchain.verbosity = {
+    blockchainLogs: true,
+    vmLogs: 'none',
+    debugLogs: false,
+}
+```
+Note that unlike with `setVerbosityForAddress`, with this setter you have to specify all the values from `LogsVerbosity`.
+
+### Setting smart contract state directly
+
+If you want to test some behavior on a contract if it had specific code, data, and other state fields, but do not want to execute all the required transactions for that, you can directly set the full state of the contract as it is stored in sandbox by using this method on the `Blockchain` instance:
+```
+async setShardAccount(address: Address, account: ShardAccount)
+```
+There are 2 helpers exported from sandbox that can help you create the `ShardAccount` from the common properties: `createEmptyShardAccount` and `createShardAccount`.
+
+Note that this is a low-level function and does not check any invariants, such as that the address passed as the argument matches the one that is present in the `ShardAccount`, meaning it is possible to break stuff if you're not careful when using it.
+
+### Network/Block configuration
+
+By default, this package will use its [stored network configuration](src/config/defaultConfig.ts) to emulate messages. However, you can set any configuration you want when creating the `Blockchain` instance by passing the configuration cell in the optional `params` argument in the `config` field.
+
+## Contributors
+
+Special thanks to [@dungeon-master-666](https://github.com/dungeon-master-666) for their C++ code of the emulator.
+
+Special thanks to [@TrueCarry](https://github.com/truecarry) for their help with performance and other suggestions.
+
+## License
+
+This package is released under the [MIT License](LICENSE).
+
+## Donations
+
+TON - `EQAQR1d1Q4NaE5EefwUMdrr1QvXg-8mDB0XI2-fwDBD0nYxC`

package/dist/blockchain/Blockchain.d.ts

@@ -0,0 +1,120 @@
+import { Address, Cell, Message, Transaction, ContractProvider, Contract, Sender, ShardAccount, TupleItem, ExternalAddress, StateInit } from "ton-core";
+import { Executor, TickOrTock } from "../executor/Executor";
+import { BlockchainStorage } from "./BlockchainStorage";
+import { Event } from "../event/Event";
+import { SandboxContractProvider } from "./BlockchainContractProvider";
+import { TreasuryContract } from "../treasury/Treasury";
+import { GetMethodParams, LogsVerbosity, MessageParams, SmartContract, SmartContractSnapshot, Verbosity } from "./SmartContract";
+import { AsyncLock } from "../utils/AsyncLock";
+export type ExternalOutInfo = {
+    type: 'external-out';
+    src: Address;
+    dest?: ExternalAddress;
+    createdAt: number;
+    createdLt: bigint;
+};
+export type ExternalOut = {
+    info: ExternalOutInfo;
+    init?: StateInit;
+    body: Cell;
+};
+export type BlockchainTransaction = Transaction & {
+    blockchainLogs: string;
+    vmLogs: string;
+    debugLogs: string;
+    events: Event[];
+    parent?: BlockchainTransaction;
+    children: BlockchainTransaction[];
+    externals: ExternalOut[];
+};
+export type SendMessageResult = {
+    transactions: BlockchainTransaction[];
+    events: Event[];
+    externals: ExternalOut[];
+};
+type ExtendsContractProvider<T> = T extends ContractProvider ? true : (T extends SandboxContractProvider ? true : false);
+export type SandboxContract<F> = {
+    [P in keyof F]: P extends `get${string}` ? (F[P] extends (x: infer CP, ...args: infer P) => infer R ? (ExtendsContractProvider<CP> extends true ? (...args: P) => R : never) : never) : (P extends `send${string}` ? (F[P] extends (x: infer CP, ...args: infer P) => infer R ? (ExtendsContractProvider<CP> extends true ? (...args: P) => Promise<SendMessageResult & {
+        result: R extends Promise<infer PR> ? PR : R;
+    }> : never) : never) : F[P]);
+};
+export type PendingMessage = (({
+    type: 'message';
+} & Message) | ({
+    type: 'ticktock';
+    which: TickOrTock;
+    on: Address;
+})) & {
+    parentTransaction?: BlockchainTransaction;
+};
+export type TreasuryParams = Partial<{
+    workchain: number;
+    predeploy: boolean;
+    balance: bigint;
+    resetBalanceIfZero: boolean;
+}>;
+export type BlockchainConfig = Cell | 'default' | 'slim';
+export type BlockchainSnapshot = {
+    contracts: SmartContractSnapshot[];
+    networkConfig: string;
+    lt: bigint;
+    time?: number;
+    verbosity: LogsVerbosity;
+    libs?: Cell;
+    nextCreateWalletIndex: number;
+};
+export declare class Blockchain {
+    protected storage: BlockchainStorage;
+    protected networkConfig: string;
+    protected currentLt: bigint;
+    protected currentTime?: number;
+    protected messageQueue: PendingMessage[];
+    protected logsVerbosity: LogsVerbosity;
+    protected globalLibs?: Cell;
+    protected lock: AsyncLock;
+    protected contractFetches: Map<string, Promise<SmartContract>>;
+    protected nextCreateWalletIndex: number;
+    readonly executor: Executor;
+    snapshot(): BlockchainSnapshot;
+    loadFrom(snapshot: BlockchainSnapshot): Promise<void>;
+    get now(): number | undefined;
+    set now(now: number | undefined);
+    get lt(): bigint;
+    protected constructor(opts: {
+        executor: Executor;
+        config?: BlockchainConfig;
+        storage: BlockchainStorage;
+    });
+    get config(): Cell;
+    get configBase64(): string;
+    sendMessage(message: Message | Cell, params?: MessageParams): Promise<SendMessageResult>;
+    runTickTock(on: Address | Address[], which: TickOrTock, params?: MessageParams): Promise<SendMessageResult>;
+    runGetMethod(address: Address, method: number | string, stack?: TupleItem[], params?: GetMethodParams): Promise<import("./SmartContract").GetMethodResult>;
+    protected pushMessage(message: Message | Cell): Promise<void>;
+    protected pushTickTock(on: Address, which: TickOrTock): Promise<void>;
+    protected runQueue(params?: MessageParams): Promise<SendMessageResult>;
+    protected processQueue(params?: MessageParams): Promise<BlockchainTransaction[]>;
+    provider(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    }): ContractProvider;
+    sender(address: Address): Sender;
+    protected treasuryParamsToMapKey(workchain: number, seed: string): string;
+    treasury(seed: string, params?: TreasuryParams): Promise<SandboxContract<TreasuryContract>>;
+    createWallets(n: number, params?: TreasuryParams): Promise<SandboxContract<TreasuryContract>[]>;
+    openContract<T extends Contract>(contract: T): SandboxContract<T>;
+    protected startFetchingContract(address: Address): Promise<SmartContract>;
+    getContract(address: Address): Promise<SmartContract>;
+    get verbosity(): LogsVerbosity;
+    set verbosity(value: LogsVerbosity);
+    setVerbosityForAddress(address: Address, verbosity: Partial<LogsVerbosity> | Verbosity | undefined): Promise<void>;
+    setConfig(config: BlockchainConfig): void;
+    setShardAccount(address: Address, account: ShardAccount): Promise<void>;
+    get libs(): Cell | undefined;
+    set libs(value: Cell | undefined);
+    static create(opts?: {
+        config?: BlockchainConfig;
+        storage?: BlockchainStorage;
+    }): Promise<Blockchain>;
+}
+export {};