@ton/sandbox 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.12.0] - 2023-10-03
+
+### Added
+
+- Step by step execution (`blockchain.sendMessageIter`)
+- Better docs
+
+### Fixed
+
+- `now` from `Blockchain` is now honored in `SmartContract.receiveMessage`
+- Exit code 1 is now counted as success in get methods
+
+## [0.11.1] - 2023-07-26
+
+### Changed
+
+- Migrated dependencies to @ton organization packages
+- Bumped @ton/test-utils version to 0.3.1
+
 ## [0.11.0] - 2023-05-11
 
 ### Added

package/README.md

@@ -4,16 +4,32 @@ This package allows you to emulate arbitrary TON smart contracts, send messages
 
 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.
 
+## Content
+
+* [Instalation](#installation)
+* [Usage](#usage)
+* [Writing Tests](#writing-tests)
+  * [Basic test template](#basic-test-template)
+  * [Test a transaction with matcher](#test-a-transaction-with-matcher)
+  * [Testing transaction fees](#testing-transaction-fees)
+  * [Cross contract tests](#cross-contract-tests)
+  * [Test examples](#test-examples)
+* [Viewing logs](#viewing-logs)
+* [Network/Block configuration](#networkblock-configuration)
+* [Contributors](#contributors)
+* [License](#license)
+* [Donations](#donations)
+
 ## Installation
 
 Requires node 16 or higher.
 
 ```
-yarn add @ton/sandbox ton @ton/core ton-crypto
+yarn add @ton/sandbox @ton/ton @ton/core @ton/crypto
 ```
 or
 ```
-npm i @ton/sandbox ton @ton/core ton-crypto
+npm i @ton/sandbox @ton/ton @ton/core @ton/crypto
 ```
 
 ## Usage
@@ -25,14 +41,14 @@ 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.
+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";
+import { Address, beginCell, Cell, Contract, ContractProvider, Sender, toNano, Builder } from "@ton/core";
 
 class NftItem implements Contract {
     async sendTransfer(provider: ContractProvider, via: Sender, params: {
@@ -62,7 +78,7 @@ When you call `nftItem.sendTransfer(treasury.getSender(), { to: recipient })` (w
 
 Here is another excerpt that shows the way to interact with get methods from wrappers:
 ```typescript
-import { Contract, ContractProvider } from "ton-core";
+import { Contract, ContractProvider } from "@ton/core";
 
 export type NftItemData = {
     inited: boolean
@@ -94,10 +110,70 @@ Notes:
 - 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
 
+### Basic test template
+
 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!
 
+Writing tests in Sandbox works through defining arbitary actions with the contract and comparing their results with the expected result, for example:
+
+```typescript
+it('should execute with success', async () => {                              // description of the test case
+    const res = await main.sendMessage(sender.getSender(), toNano('0.05'));  // performing an action with contract main and saving result in res
+
+    expect(res.transactions).toHaveTransaction({                             // configure the expected result with expect() function
+        from: main.address,                                                  // set expected sender for transaction we want to test matcher properties from
+        success: true                                                        // set the desirable result using matcher property success
+    });
+
+    printTransactionFees(res.transactions);                                  // print table with details on spent fees
+});
+```
+
+
+### Test a transaction with matcher
+
+The basic workflow of creating a test is:
+1. Create a specific wrapped `Contract` entity using `blockchain.openContract()`.
+2. Describe the actions your `Contract` should perform and save the execution result in `res` variable.
+3. Verify the properties using the `expect()` function and the matcher `toHaveTransaction()`.
+
+The `toHaveTransaction` matcher expects an object with any combination of fields from the `FlatTransaction` type defined with the following properties
+
+| Name                 | Type          | Description                                                                                                                                                         |
+|----------------------|---------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| from                 | Address?      | Contract address of the message sender                                                                                                                              |
+| to                   | Address       | Contract address of the message destination                                                                                                                         |
+| on                   | Address       | Contract address of the message destination  (Alternative name of the property `to`).                                                                               |
+| value                | bigint?       | Amount of Toncoins in the message in nanotons                                                                                                                       |
+| body                 | Cell          | Message body defined as a Cell                                                                                                                                              |
+| inMessageBounced     | boolean?      | Boolean flag Bounced. True - message is bounced, False - message is not bounced.                                                                                    |
+| inMessageBounceable  | boolean?      | Boolean flag Bounceable. True - message can be bounced, False - message can not be bounced.                                                                         |
+| op                   | number?       | Op code is the operation identifier number (crc32 from TL-B usually). Expected in the first 32 bits of a message body.                                              |
+| initData             | Cell?         | InitData Cell. Used for contract deployment processes.                                                                                                              |
+| initCode             | Cell?         | initCode Cell. Used for contract deployment processes.                                                                                                              |
+| deploy               | boolean       | Custom Sandbox flag that indicates whether the contract was deployed during this transaction. True if contract before this transaction was not initialized and after this transaction became initialized. Otherwise - False.  |
+| lt                   | bigint        | Logical time (set by validators in a normal network, monotonically increases by a set interval in Sandbox). Used for defining order of transactions related to a certain contract                                                           |
+| now                  | bigint        | Unix timestamp of the transaction                                                                                                                                       |
+| outMessagesCount     | number        | Quantity of outbound messages in a certain transaction                                                                                                              |
+| oldStatus            | AccountStatus | AccountStatus before transaction execution                                                                                                                              |
+| endStatus            | AccountStatus | AccountStatus after transaction execution                                                                                                                               |
+| totalFees            | bigint?        | Number of spent fees in nanotons                                                                                                                                    |
+|aborted| boolean?       | True - execution of certain transaction aborted and rollbacked because of errors or insufficient gas. Otherwise - False.                                            |
+|destroyed| boolean?       | True - if the existing contract was destroyed due to executing a certain transaction. Otherwise - False.                                                            |
+|exitCode| number?        | TVM exit code (from compute phase)                                                                                                                                |
+|actionResultCode| number? | Action phase result code |
+|success| boolean?       | Custom Sandbox flag that defines the resulting status of a certain transaction. True - if both the compute and the action phase succeeded. Otherwise - False.       |
+
+
+You can omit those that 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.
+
+
+
 Here is an excerpt of how it's used in the NFT collection example mentioned above:
 ```typescript
 const buyResult = await buyer.send({
@@ -119,32 +195,80 @@ expect(buyResult.transactions).toHaveTransaction({
 ```
 (in that example `jest` is used)
 
-The matcher supports the following fields:
+
+### Testing transaction fees
+It is possible to configure and update the current time of the `Blockchain`, which allows one to inspect how much a contract would spend on storage fees.
+
+Suppose we have a `main` instance defined as a wrapped `Contract` instance `main = blockchain.openContract(/* non-wrapped Main instance */)`, and we wish to determine the amount of storage fees that will be accrued between two actions within a specified period.
+
 ```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
-}
+it('should storage fees cost less than 1 TON', async () => {
+    const time1 = Math.floor(Date.now() / 1000);                               // current local unix time
+    const time2 = time1 + 365 * 24 * 60 * 60;                                  // offset for a year
+
+    blockchain.now = time1;                                                    // set current time
+    const res1 = await main.sendMessage(sender.getSender(), toNano('0.05'));   // preview of fees 
+    printTransactionFees(res1.transactions);
+
+    blockchain.now = time2;                                                    // set current time
+    const res2 = await main.sendMessage(sender.getSender(), toNano('0.05'));   // preview of fees 
+    printTransactionFees(res2.transactions);
+    
+    const tx2 = res2.transactions[1];                                          // extract the transaction that executed in a year
+    if (tx2.description.type !== 'generic') {
+        throw new Error('Generic transaction expected');
+    }
+
+    // Check that the storagePhase fees are less than 1 TON over the course of a year
+    expect(tx2.description.storagePhase?.storageFeesCollected).toBeLessThanOrEqual(toNano('1'));   
+});
 ```
 
-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.
+### Cross contract tests
+
+The Sandbox emulates the entire process of executing cross-contract interactions as if they occurred on a real blockchain. 
+The result of sending a message (transfer) contains basic information about all transactions and actions. 
+You can verify all of these by creating specific requirements via `expect()` for each action and transaction.
+
+```typescript
+res = await main.sendMessage(...);
+
+expect(res).toHaveTransaction(...) // test case 
+        <...>
+expect(res).toHaveTransaction(...) // test case
+```
+
+For instance, with [Modern Jetton](https://github.com/EmelyanenkoK/modern_jetton) it's possible to test whether a `mint` message results in minting to a new jetton wallet contract and returns the excess to the minter contract.
+```typescript
+it('minter admin should be able to mint jettons', async () => {
+    // can mint from deployer
+    let initialTotalSupply = await jettonMinter.getTotalSupply();
+    const deployerJettonWallet = await userWallet(deployer.address);
+    let initialJettonBalance = toNano('1000.23');
+    const mintResult = await jettonMinter.sendMint(deployer.getSender(), deployer.address, initialJettonBalance, toNano('0.05'), toNano('1'));
+
+    expect(mintResult.transactions).toHaveTransaction({ // test transaction of deployment of a jetton wallet
+        from: jettonMinter.address,
+        to: deployerJettonWallet.address,
+        deploy: true,
+    });
+
+    expect(mintResult.transactions).toHaveTransaction({ // test transaction of excesses returned to minter
+        from: deployerJettonWallet.address,
+        to: jettonMinter.address
+    });
+
+});
+```
+
+### Test Examples
+You can typically find various tests for Sandbox-based project contracts in the `./tests` directory. 
+Learn more from examples:
+
+* [FunC Test Examples](https://docs.ton.org/develop/smart-contracts/examples#examples-of-tests-for-smart-contracts)
+* [Tact Test Examples](docs/tact-testing-examples.md) 
 
-### Viewing logs
+## Viewing logs
 
 `Blockchain` and `SmartContract` use `LogsVerbosity` to determine what kinds of logs to print. Here is the definition:
 ```typescript
@@ -185,7 +309,7 @@ blockchain.verbosity = {
 ```
 Note that unlike with `setVerbosityForAddress`, with this setter you have to specify all the values from `LogsVerbosity`.
 
-### Setting smart contract state directly
+## 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:
 ```
@@ -195,7 +319,7 @@ There are 2 helpers exported from sandbox that can help you create the `ShardAcc
 
 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
+## 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.
 

package/dist/blockchain/Blockchain.d.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, Message, Transaction, ContractProvider, Contract, Sender, ShardAccount, TupleItem, ExternalAddress, StateInit } from "ton-core";
+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";
@@ -88,11 +88,15 @@ export declare class Blockchain {
     get config(): Cell;
     get configBase64(): string;
     sendMessage(message: Message | Cell, params?: MessageParams): Promise<SendMessageResult>;
+    sendMessageIter(message: Message | Cell, params?: MessageParams): Promise<AsyncIterator<BlockchainTransaction> & AsyncIterable<BlockchainTransaction>>;
     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 txIter(needsLocking: boolean, params?: MessageParams): AsyncIterator<BlockchainTransaction> & AsyncIterable<BlockchainTransaction>;
+    protected processInternal(params?: MessageParams): Promise<IteratorResult<BlockchainTransaction>>;
+    protected processTx(needsLocking: boolean, params?: MessageParams): Promise<IteratorResult<BlockchainTransaction>>;
     protected processQueue(params?: MessageParams): Promise<BlockchainTransaction[]>;
     provider(address: Address, init?: {
         code: Cell;

package/dist/blockchain/Blockchain.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Blockchain = void 0;
 const defaultConfig_1 = require("../config/defaultConfig");
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 const Executor_1 = require("../executor/Executor");
 const BlockchainStorage_1 = require("./BlockchainStorage");
 const Event_1 = require("../event/Event");
@@ -80,7 +80,7 @@ class Blockchain {
         this.storage = opts.storage;
     }
     get config() {
-        return ton_core_1.Cell.fromBase64(this.networkConfig);
+        return core_1.Cell.fromBase64(this.networkConfig);
     }
     get configBase64() {
         return this.networkConfig;
@@ -89,6 +89,15 @@ class Blockchain {
         await this.pushMessage(message);
         return await this.runQueue(params);
     }
+    async sendMessageIter(message, params) {
+        params = {
+            now: this.now,
+            ...params,
+        };
+        await this.pushMessage(message);
+        // Iterable will lock on per tx basis
+        return await this.txIter(true, params);
+    }
     async runTickTock(on, which, params) {
         for (const addr of (Array.isArray(on) ? on : [on])) {
             await this.pushTickTock(addr, which);
@@ -102,7 +111,7 @@ class Blockchain {
         });
     }
     async pushMessage(message) {
-        const msg = message instanceof ton_core_1.Cell ? (0, ton_core_1.loadMessage)(message.beginParse()) : message;
+        const msg = message instanceof core_1.Cell ? (0, core_1.loadMessage)(message.beginParse()) : message;
         if (msg.info.type === 'external-out') {
             throw new Error('Cannot send external out message');
         }
@@ -130,60 +139,80 @@ class Blockchain {
             externals: txes.map(tx => tx.externals).flat(),
         };
     }
+    txIter(needsLocking, params) {
+        const it = { next: () => this.processTx(needsLocking, params), [Symbol.asyncIterator]() { return it; } };
+        return it;
+    }
+    async processInternal(params) {
+        let result = undefined;
+        let done = this.messageQueue.length == 0;
+        while (!done) {
+            const message = this.messageQueue.shift();
+            let tx;
+            if (message.type === 'message') {
+                if (message.info.type === 'external-out') {
+                    done = this.messageQueue.length == 0;
+                    continue;
+                }
+                this.currentLt += LT_ALIGN;
+                tx = (await this.getContract(message.info.dest)).receiveMessage(message, params);
+            }
+            else {
+                this.currentLt += LT_ALIGN;
+                tx = (await this.getContract(message.on)).runTickTock(message.which, params);
+            }
+            const transaction = {
+                ...tx,
+                events: (0, Event_1.extractEvents)(tx),
+                parent: message.parentTransaction,
+                children: [],
+                externals: [],
+            };
+            transaction.parent?.children.push(transaction);
+            result = transaction;
+            done = true;
+            for (const message of transaction.outMessages.values()) {
+                if (message.info.type === 'external-out') {
+                    transaction.externals.push({
+                        info: {
+                            type: 'external-out',
+                            src: message.info.src,
+                            dest: message.info.dest ?? undefined,
+                            createdAt: message.info.createdAt,
+                            createdLt: message.info.createdLt,
+                        },
+                        init: message.init ?? undefined,
+                        body: message.body,
+                    });
+                    continue;
+                }
+                this.messageQueue.push({
+                    type: 'message',
+                    parentTransaction: transaction,
+                    ...message,
+                });
+                if (message.info.type === 'internal') {
+                    this.startFetchingContract(message.info.dest);
+                }
+            }
+        }
+        return result === undefined ? { value: result, done: true } : { value: result, done: false };
+    }
+    async processTx(needsLocking, params) {
+        // Lock only if not locked already
+        return needsLocking ? await this.lock.with(async () => this.processInternal(params)) : await this.processInternal(params);
+    }
     async processQueue(params) {
         params = {
             now: this.now,
             ...params,
         };
         return await this.lock.with(async () => {
+            // Locked already
+            const txs = this.txIter(false, params);
             const result = [];
-            while (this.messageQueue.length > 0) {
-                const message = this.messageQueue.shift();
-                let tx;
-                if (message.type === 'message') {
-                    if (message.info.type === 'external-out') {
-                        continue;
-                    }
-                    this.currentLt += LT_ALIGN;
-                    tx = (await this.getContract(message.info.dest)).receiveMessage(message, params);
-                }
-                else {
-                    this.currentLt += LT_ALIGN;
-                    tx = (await this.getContract(message.on)).runTickTock(message.which, params);
-                }
-                const transaction = {
-                    ...tx,
-                    events: (0, Event_1.extractEvents)(tx),
-                    parent: message.parentTransaction,
-                    children: [],
-                    externals: [],
-                };
-                transaction.parent?.children.push(transaction);
-                result.push(transaction);
-                for (const message of transaction.outMessages.values()) {
-                    if (message.info.type === 'external-out') {
-                        transaction.externals.push({
-                            info: {
-                                type: 'external-out',
-                                src: message.info.src,
-                                dest: message.info.dest ?? undefined,
-                                createdAt: message.info.createdAt,
-                                createdLt: message.info.createdLt,
-                            },
-                            init: message.init ?? undefined,
-                            body: message.body,
-                        });
-                        continue;
-                    }
-                    this.messageQueue.push({
-                        type: 'message',
-                        parentTransaction: transaction,
-                        ...message,
-                    });
-                    if (message.info.type === 'internal') {
-                        this.startFetchingContract(message.info.dest);
-                    }
-                }
+            for await (const tx of txs) {
+                result.push(tx);
             }
             return result;
         });
@@ -210,15 +239,15 @@ class Blockchain {
         const contract = await this.getContract(wallet.address);
         if ((params?.predeploy ?? true) && (contract.accountState === undefined || contract.accountState.type === 'uninit')) {
             await this.sendMessage((0, message_1.internal)({
-                from: new ton_core_1.Address(0, Buffer.alloc(32)),
+                from: new core_1.Address(0, Buffer.alloc(32)),
                 to: wallet.address,
-                value: (0, ton_core_1.toNano)(1),
+                value: (0, core_1.toNano)(1),
                 stateInit: wallet.init,
             }));
-            contract.balance = params?.balance ?? (0, ton_core_1.toNano)(TREASURY_INIT_BALANCE_TONS);
+            contract.balance = params?.balance ?? (0, core_1.toNano)(TREASURY_INIT_BALANCE_TONS);
         }
         else if ((params?.resetBalanceIfZero ?? true) && contract.balance === 0n) {
-            contract.balance = params?.balance ?? (0, ton_core_1.toNano)(TREASURY_INIT_BALANCE_TONS);
+            contract.balance = params?.balance ?? (0, core_1.toNano)(TREASURY_INIT_BALANCE_TONS);
         }
         return wallet;
     }
@@ -233,15 +262,15 @@ class Blockchain {
     openContract(contract) {
         let address;
         let init = undefined;
-        if (!ton_core_1.Address.isAddress(contract.address)) {
+        if (!core_1.Address.isAddress(contract.address)) {
             throw Error('Invalid address');
         }
         address = contract.address;
         if (contract.init) {
-            if (!(contract.init.code instanceof ton_core_1.Cell)) {
+            if (!(contract.init.code instanceof core_1.Cell)) {
                 throw Error('Invalid init.code');
             }
-            if (!(contract.init.data instanceof ton_core_1.Cell)) {
+            if (!(contract.init.data instanceof core_1.Cell)) {
                 throw Error('Invalid init.data');
             }
             init = contract.init;

package/dist/blockchain/BlockchainContractProvider.d.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, ContractGetMethodResult, ContractProvider, ContractState, Message, Sender, SendMode, TupleItem } from "ton-core";
+import { Address, Cell, ContractGetMethodResult, ContractProvider, ContractState, Message, Sender, SendMode, TupleItem } from "@ton/core";
 import { TickOrTock } from "../executor/Executor";
 import { GetMethodResult, SmartContract } from "./SmartContract";
 export interface SandboxContractProvider extends ContractProvider {

package/dist/blockchain/BlockchainContractProvider.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockchainContractProvider = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 function bigintToBuffer(x, n = 32) {
     const b = Buffer.alloc(n);
     for (let i = 0; i < n; i++) {
@@ -72,8 +72,8 @@ class BlockchainContractProvider {
     async internal(via, args) {
         const init = ((await this.getState()).state.type !== 'active' && this.init) ? this.init : undefined;
         const bounce = (args.bounce !== null && args.bounce !== undefined) ? args.bounce : true;
-        const value = typeof args.value === 'string' ? (0, ton_core_1.toNano)(args.value) : args.value;
-        const body = typeof args.body === 'string' ? (0, ton_core_1.comment)(args.body) : args.body;
+        const value = typeof args.value === 'string' ? (0, core_1.toNano)(args.value) : args.value;
+        const body = typeof args.body === 'string' ? (0, core_1.comment)(args.body) : args.body;
         await via.send({
             to: this.address,
             value,

package/dist/blockchain/BlockchainSender.d.ts

@@ -1,4 +1,4 @@
-import { Address, Message, Sender, SenderArguments } from "ton-core";
+import { Address, Message, Sender, SenderArguments } from "@ton/core";
 export declare class BlockchainSender implements Sender {
     private readonly blockchain;
     readonly address: Address;

package/dist/blockchain/BlockchainSender.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockchainSender = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 class BlockchainSender {
     constructor(blockchain, address) {
         this.blockchain = blockchain;
@@ -22,7 +22,7 @@ class BlockchainSender {
                 createdAt: 0,
                 createdLt: 0n,
             },
-            body: args.body ?? new ton_core_1.Cell()
+            body: args.body ?? new core_1.Cell()
         });
     }
 }

package/dist/blockchain/BlockchainStorage.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { AccountState, Address } from "ton-core";
+import { AccountState, Address } from "@ton/core";
 import { SmartContract } from "./SmartContract";
 import { Blockchain } from "./Blockchain";
 export interface BlockchainStorage {

package/dist/blockchain/BlockchainStorage.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteBlockchainStorage = exports.wrapTonClient4ForRemote = exports.LocalBlockchainStorage = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 const SmartContract_1 = require("./SmartContract");
 class LocalBlockchainStorage {
     constructor() {
@@ -28,7 +28,7 @@ function convertTonClient4State(state) {
         case 'uninit':
             return { type: 'uninit' };
         case 'active':
-            return { type: 'active', state: { code: state.code === null ? undefined : ton_core_1.Cell.fromBase64(state.code), data: state.data === null ? undefined : ton_core_1.Cell.fromBase64(state.data) } };
+            return { type: 'active', state: { code: state.code === null ? undefined : core_1.Cell.fromBase64(state.code), data: state.data === null ? undefined : core_1.Cell.fromBase64(state.data) } };
         case 'frozen':
             return { type: 'frozen', stateHash: BigInt('0x' + Buffer.from(state.stateHash, 'base64').toString('hex')) };
         default:

package/dist/blockchain/SmartContract.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Blockchain } from "./Blockchain";
-import { Address, Cell, Message, ShardAccount, Transaction, TupleItem, TupleReader } from "ton-core";
+import { Address, Cell, Message, ShardAccount, Transaction, TupleItem, TupleReader } from "@ton/core";
 import { EmulationResult, RunCommonArgs, TickOrTock } from "../executor/Executor";
 export declare function createShardAccount(args: {
     address?: Address;
@@ -72,7 +72,7 @@ export declare class SmartContract {
     set balance(v: bigint);
     get lastTransactionHash(): bigint;
     get lastTransactionLt(): bigint;
-    get accountState(): import("ton-core").AccountState | undefined;
+    get accountState(): import("@ton/core").AccountState | undefined;
     get account(): ShardAccount;
     set account(account: ShardAccount);
     static create(blockchain: Blockchain, args: {

package/dist/blockchain/SmartContract.js

@@ -13,11 +13,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _SmartContract_account, _SmartContract_parsedAccount, _SmartContract_lastTxTime, _SmartContract_verbosity;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartContract = exports.TimeError = exports.GetMethodError = exports.createEmptyShardAccount = exports.createShardAccount = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 const selector_1 = require("../utils/selector");
 function createShardAccount(args) {
     let wc = args.workchain ?? 0;
-    let address = args.address ?? (0, ton_core_1.contractAddress)(wc, { code: args.code, data: args.data });
+    let address = args.address ?? (0, core_1.contractAddress)(wc, { code: args.code, data: args.data });
     let balance = args.balance ?? 0n;
     return {
         account: {
@@ -105,7 +105,7 @@ class SmartContract {
         _SmartContract_lastTxTime.set(this, void 0);
         _SmartContract_verbosity.set(this, void 0);
         this.address = shardAccount.account.addr;
-        __classPrivateFieldSet(this, _SmartContract_account, (0, ton_core_1.beginCell)().store((0, ton_core_1.storeShardAccount)(shardAccount)).endCell().toBoc().toString('base64'), "f");
+        __classPrivateFieldSet(this, _SmartContract_account, (0, core_1.beginCell)().store((0, core_1.storeShardAccount)(shardAccount)).endCell().toBoc().toString('base64'), "f");
         __classPrivateFieldSet(this, _SmartContract_parsedAccount, shardAccount, "f");
         __classPrivateFieldSet(this, _SmartContract_lastTxTime, shardAccount.account?.storageStats.lastPaid ?? 0, "f");
         this.blockchain = blockchain;
@@ -148,12 +148,12 @@ class SmartContract {
     }
     get account() {
         if (__classPrivateFieldGet(this, _SmartContract_parsedAccount, "f") === undefined) {
-            __classPrivateFieldSet(this, _SmartContract_parsedAccount, (0, ton_core_1.loadShardAccount)(ton_core_1.Cell.fromBase64(__classPrivateFieldGet(this, _SmartContract_account, "f")).beginParse()), "f");
+            __classPrivateFieldSet(this, _SmartContract_parsedAccount, (0, core_1.loadShardAccount)(core_1.Cell.fromBase64(__classPrivateFieldGet(this, _SmartContract_account, "f")).beginParse()), "f");
         }
         return __classPrivateFieldGet(this, _SmartContract_parsedAccount, "f");
     }
     set account(account) {
-        __classPrivateFieldSet(this, _SmartContract_account, (0, ton_core_1.beginCell)().store((0, ton_core_1.storeShardAccount)(account)).endCell().toBoc().toString('base64'), "f");
+        __classPrivateFieldSet(this, _SmartContract_account, (0, core_1.beginCell)().store((0, core_1.storeShardAccount)(account)).endCell().toBoc().toString('base64'), "f");
         __classPrivateFieldSet(this, _SmartContract_parsedAccount, account, "f");
         __classPrivateFieldSet(this, _SmartContract_lastTxTime, account.account?.storageStats.lastPaid ?? 0, "f");
     }
@@ -181,9 +181,14 @@ class SmartContract {
         };
     }
     receiveMessage(message, params) {
+        // Sync now with blockchain instance if not specified in parameters
+        params = {
+            now: this.blockchain.now,
+            ...params,
+        };
         return this.runCommon(() => this.blockchain.executor.runTransaction({
             ...this.createCommonArgs(params),
-            message: (0, ton_core_1.beginCell)().store((0, ton_core_1.storeMessage)(message)).endCell(),
+            message: (0, core_1.beginCell)().store((0, core_1.storeMessage)(message)).endCell(),
         }));
     }
     runTickTock(which, params) {
@@ -207,7 +212,7 @@ class SmartContract {
         if (this.verbosity.print && this.verbosity.debugLogs && res.debugLogs.length > 0) {
             console.log(res.debugLogs);
         }
-        const tx = (0, ton_core_1.loadTransaction)(ton_core_1.Cell.fromBase64(res.result.transaction).beginParse());
+        const tx = (0, core_1.loadTransaction)(core_1.Cell.fromBase64(res.result.transaction).beginParse());
         __classPrivateFieldSet(this, _SmartContract_account, res.result.shardAccount, "f");
         __classPrivateFieldSet(this, _SmartContract_parsedAccount, undefined, "f");
         __classPrivateFieldSet(this, _SmartContract_lastTxTime, tx.now, "f");
@@ -249,13 +254,13 @@ class SmartContract {
         if (this.verbosity.print && this.verbosity.debugLogs && res.debugLogs.length > 0) {
             console.log(res.debugLogs);
         }
-        if (res.output.vm_exit_code !== 0) {
+        if (res.output.vm_exit_code !== 0 && res.output.vm_exit_code !== 1) {
             throw new GetMethodError(res.output.vm_exit_code, BigInt(res.output.gas_used), res.logs, res.output.vm_log, res.debugLogs);
         }
-        const resStack = (0, ton_core_1.parseTuple)(ton_core_1.Cell.fromBase64(res.output.stack));
+        const resStack = (0, core_1.parseTuple)(core_1.Cell.fromBase64(res.output.stack));
         return {
             stack: resStack,
-            stackReader: new ton_core_1.TupleReader(resStack),
+            stackReader: new core_1.TupleReader(resStack),
             exitCode: res.output.vm_exit_code,
             gasUsed: BigInt(res.output.gas_used),
             blockchainLogs: res.logs,

package/dist/event/Event.d.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, Transaction } from "ton-core";
+import { Address, Cell, Transaction } from "@ton/core";
 export type EventAccountCreated = {
     type: 'account_created';
     account: Address;

package/dist/executor/Executor.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Address, Cell, TupleItem } from "ton-core";
+import { Address, Cell, TupleItem } from "@ton/core";
 export type GetMethodArgs = {
     code: Cell;
     data: Cell;

package/dist/executor/Executor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Executor = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 const base64_1 = require("../utils/base64");
 const EmulatorModule = require('./emulator-emscripten.js');
 const verbosityToNum = {
@@ -93,7 +93,7 @@ class Executor {
             method_id: args.methodId,
             debug_enabled: args.debugEnabled,
         };
-        let stack = (0, ton_core_1.serializeTuple)(args.stack);
+        let stack = (0, core_1.serializeTuple)(args.stack);
         this.debugLogs = [];
         const resp = JSON.parse(this.extractString(this.invoke('_run_get_method', [
             JSON.stringify(params),

package/dist/treasury/Treasury.d.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SenderArguments, SendMode } from "ton-core";
+import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SenderArguments, SendMode } from "@ton/core";
 export type Treasury = Sender & {
     address: Address;
 };

package/dist/treasury/Treasury.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreasuryContract = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 const DictionaryMessageValue = {
     serialize(src, builder) {
         builder.storeUint(src.sendMode, 8);
-        builder.storeRef((0, ton_core_1.beginCell)().store((0, ton_core_1.storeMessageRelaxed)(src.message)));
+        builder.storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(src.message)));
     },
     parse(src) {
         let sendMode = src.loadUint(8);
-        let message = (0, ton_core_1.loadMessageRelaxed)(src.loadRef().beginParse());
+        let message = (0, core_1.loadMessageRelaxed)(src.loadRef().beginParse());
         return { sendMode, message };
     },
 };
 function senderArgsToMessageRelaxed(args) {
-    return (0, ton_core_1.internal)({
+    return (0, core_1.internal)({
         to: args.to,
         value: args.value,
         init: args.init,
@@ -27,11 +27,11 @@ class TreasuryContract {
         return new TreasuryContract(workchain, subwalletId);
     }
     constructor(workchain, subwalletId) {
-        const data = (0, ton_core_1.beginCell)()
+        const data = (0, core_1.beginCell)()
             .storeUint(subwalletId, 256)
             .endCell();
         this.init = { code: TreasuryContract.code, data };
-        this.address = (0, ton_core_1.contractAddress)(workchain, this.init);
+        this.address = (0, core_1.contractAddress)(workchain, this.init);
         this.subwalletId = subwalletId;
     }
     async sendMessages(provider, messages, sendMode) {
@@ -60,23 +60,23 @@ class TreasuryContract {
         return (await provider.getState()).balance;
     }
     createTransfer(args) {
-        let sendMode = ton_core_1.SendMode.PAY_GAS_SEPARATELY;
+        let sendMode = core_1.SendMode.PAY_GAS_SEPARATELY;
         if (args.sendMode !== null && args.sendMode !== undefined) {
             sendMode = args.sendMode;
         }
         if (args.messages.length > 255) {
             throw new Error('Maximum number of messages is 255');
         }
-        let messages = ton_core_1.Dictionary.empty(ton_core_1.Dictionary.Keys.Int(16), DictionaryMessageValue);
+        let messages = core_1.Dictionary.empty(core_1.Dictionary.Keys.Int(16), DictionaryMessageValue);
         let index = 0;
         for (let m of args.messages) {
             messages.set(index++, { sendMode, message: m });
         }
-        return (0, ton_core_1.beginCell)()
+        return (0, core_1.beginCell)()
             .storeUint(this.subwalletId, 256)
             .storeDict(messages)
             .endCell();
     }
 }
 exports.TreasuryContract = TreasuryContract;
-TreasuryContract.code = ton_core_1.Cell.fromBase64('te6cckEBBAEARQABFP8A9KQT9LzyyAsBAgEgAwIAWvLT/+1E0NP/0RK68qL0BNH4AH+OFiGAEPR4b6UgmALTB9QwAfsAkTLiAbPmWwAE0jD+omUe');
+TreasuryContract.code = core_1.Cell.fromBase64('te6cckEBBAEARQABFP8A9KQT9LzyyAsBAgEgAwIAWvLT/+1E0NP/0RK68qL0BNH4AH+OFiGAEPR4b6UgmALTB9QwAfsAkTLiAbPmWwAE0jD+omUe');

package/dist/utils/message.d.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, Message, StateInit } from "ton-core";
+import { Address, Cell, Message, StateInit } from "@ton/core";
 export declare function internal(params: {
     from: Address;
     to: Address;

package/dist/utils/message.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.internal = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 function internal(params) {
     return {
         info: {
@@ -17,7 +17,7 @@ function internal(params) {
             createdAt: params.createdAt ?? 0,
             createdLt: params.createdLt ?? 0n,
         },
-        body: params.body ?? new ton_core_1.Cell(),
+        body: params.body ?? new core_1.Cell(),
         init: params.stateInit,
     };
 }

package/dist/utils/prettyLogTransaction.d.ts

@@ -1,3 +1,3 @@
-import { Transaction } from "ton-core";
+import { Transaction } from "@ton/core";
 export declare function prettyLogTransaction(tx: Transaction): string;
 export declare function prettyLogTransactions(txs: Transaction[]): void;

package/dist/utils/prettyLogTransaction.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prettyLogTransactions = exports.prettyLogTransaction = void 0;
-const ton_core_1 = require("ton-core");
+const core_1 = require("@ton/core");
 function prettyLogTransaction(tx) {
     let res = `${tx.inMessage?.info.src}  ➡️  ${tx.inMessage?.info.dest}\n`;
     for (let message of tx.outMessages.values()) {
         if (message.info.type === 'internal') {
-            res += `     ➡️  ${(0, ton_core_1.fromNano)(message.info.value.coins)} 💎 ${message.info.dest}\n`;
+            res += `     ➡️  ${(0, core_1.fromNano)(message.info.value.coins)} 💎 ${message.info.dest}\n`;
         }
         else {
             res += `      ➡️  ${message.info.dest}\n`;

package/dist/utils/printTransactionFees.d.ts

@@ -1,3 +1,3 @@
-import { Transaction } from "ton-core";
+import { Transaction } from "@ton/core";
 export declare function formatCoinsPure(value: bigint, precision?: number): string;
 export declare function printTransactionFees(transactions: Transaction[]): void;

package/dist/utils/testTreasurySubwalletId.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testSubwalletId = void 0;
-const ton_crypto_1 = require("ton-crypto");
+const crypto_1 = require("@ton/crypto");
 const prefix = 'TESTSEED';
 function testSubwalletId(seed) {
-    return BigInt('0x' + (0, ton_crypto_1.sha256_sync)(prefix + seed).toString('hex'));
+    return BigInt('0x' + (0, crypto_1.sha256_sync)(prefix + seed).toString('hex'));
 }
 exports.testSubwalletId = testSubwalletId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ton/sandbox",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "TON transaction emulator",
   "main": "dist/index.js",
   "license": "MIT",
@@ -13,20 +13,20 @@
     "url": "git+https://github.com/ton-org/sandbox"
   },
   "devDependencies": {
-    "@ton-community/test-utils": "^0.2.0",
+    "@ton/core": "^0.49.2",
+    "@ton/crypto": "3.2.0",
+    "@ton/test-utils": "^0.3.1",
+    "@ton/ton": "^13.4.2",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
     "jest": "^29.5.0",
-    "ton": "^13.4.1",
-    "ton-core": "^0.49.0",
-    "ton-crypto": "3.2.0",
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.5"
   },
   "peerDependencies": {
-    "ton-core": ">=0.48.0",
-    "ton-crypto": ">=3.2.0"
+    "@ton/core": ">=0.49.2",
+    "@ton/crypto": ">=3.2.0"
   },
   "scripts": {
     "wasm:pack": "ts-node ./scripts/pack-wasm.ts",
@@ -34,5 +34,6 @@
     "test": "yarn wasm:pack && yarn jest src",
     "build": "rm -rf dist && yarn wasm:pack && yarn test && tsc && yarn wasm:copy",
     "config:pack": "ts-node ./scripts/pack-config.ts"
-  }
-}
+  },
+  "packageManager": "yarn@3.6.1"
+}