diff --git a/01-wallet/test/npmton/step7.expected.txt b/01-wallet/test/npmton/step7.expected.txt index a9d4efb..2962b5c 100644 --- a/01-wallet/test/npmton/step7.expected.txt +++ b/01-wallet/test/npmton/step7.expected.txt @@ -1,2 +1,2 @@ -kQBwP1UC3dbBjqOgWHNu3Nfa10FbQI-VGwck7JeOO92qnaEv +UQC9Q5w33dGVyPVVgUct_tRmYQ-JmayerW0IxN0Gf2cTtiQP workchain: 0 diff --git a/01-wallet/test/npmton/step7.ts b/01-wallet/test/npmton/step7.ts index 342f936..3501c7f 100644 --- a/01-wallet/test/npmton/step7.ts +++ b/01-wallet/test/npmton/step7.ts @@ -5,10 +5,13 @@ import { mnemonicToWalletKey } from "@ton/crypto"; import { WalletContractV4 } from "@ton/ton"; async function main() { - // use your mnemonic phrase from .end file in the root of the project and change wallet address - // const mnemonic = process.env.MNEMONIC; - // also you need to change your wallet address in step7.expected.txt to run test - const mnemonic = "memory album during buyer copper until arm forest identify race eyebrow bunker dawn phrase butter knock owner thumb click lottery catalog desk trial copper"; // your 24 secret words (replace ... with the rest of the words) + // on GH Actions test uses GH secret as mnemonic + // to run this test locally, you should create the file .env in the project root + // with your mnemonic phrase (according to repo README) + // and change step7.expected wallet address to yours + const mnemonic = process.env.MNEMONIC; + + // open wallet v4 (notice the correct wallet version here) const key = await mnemonicToWalletKey(mnemonic!.split(" ")); const wallet = WalletContractV4.create({ publicKey: key.publicKey, workchain: 0 }); diff --git a/01-wallet/test/npmton/step8.ts b/01-wallet/test/npmton/step8.ts index 021e1de..da98785 100644 --- a/01-wallet/test/npmton/step8.ts +++ b/01-wallet/test/npmton/step8.ts @@ -6,8 +6,8 @@ import { mnemonicToWalletKey } from "@ton/crypto"; import { WalletContractV4, TonClient, fromNano } from "@ton/ton"; async function main() { - // open wallet v4 (notice the correct wallet version here) - const mnemonic = process.env.MNEMONIC;; // your 24 secret words (replace ... with the rest of the words) + const mnemonic = process.env.MNEMONIC; + const key = await mnemonicToWalletKey(mnemonic!.split(" ")); const wallet = WalletContractV4.create({ publicKey: key.publicKey, workchain: 0 }); diff --git a/01-wallet/test/npmton/step9.ts b/01-wallet/test/npmton/step9.ts index c94c949..c3c4b26 100644 --- a/01-wallet/test/npmton/step9.ts +++ b/01-wallet/test/npmton/step9.ts @@ -6,7 +6,7 @@ import { mnemonicToWalletKey } from "@ton/crypto"; import { TonClient, WalletContractV4, internal } from "@ton/ton"; async function main() { - // open wallet v4 (notice the correct wallet version here) + const mnemonic = process.env.MNEMONIC; const key = await mnemonicToWalletKey(mnemonic!.split(" ")); const wallet = WalletContractV4.create({ publicKey: key.publicKey, workchain: 0 }); diff --git a/01-wallet/test/tonweb/step7.expected.txt b/01-wallet/test/tonweb/step7.expected.txt index a9d4efb..2962b5c 100644 --- a/01-wallet/test/tonweb/step7.expected.txt +++ b/01-wallet/test/tonweb/step7.expected.txt @@ -1,2 +1,2 @@ -kQBwP1UC3dbBjqOgWHNu3Nfa10FbQI-VGwck7JeOO92qnaEv +UQC9Q5w33dGVyPVVgUct_tRmYQ-JmayerW0IxN0Gf2cTtiQP workchain: 0 diff --git a/01-wallet/test/tonweb/step7.ts b/01-wallet/test/tonweb/step7.ts index 557780f..6b4c616 100644 --- a/01-wallet/test/tonweb/step7.ts +++ b/01-wallet/test/tonweb/step7.ts @@ -5,10 +5,11 @@ import { mnemonicToKeyPair } from "tonweb-mnemonic"; import TonWeb from "tonweb"; async function main() { - // use your mnemonic phrase from .end file in the root of the project and change wallet address - // const mnemonic = process.env.MNEMONIC; - // also you need to change your wallet address in step7.expected.txt to run test - const mnemonic = "memory album during buyer copper until arm forest identify race eyebrow bunker dawn phrase butter knock owner thumb click lottery catalog desk trial copper"; // your 24 secret words (replace ... with the rest of the words) + // on GH Actions test uses GH secret as mnemonic + // to run this test locally, you should create the file .env in the project root + // with your mnemonic phrase (according to repo README) + // and change step7.expected wallet address to yours + const mnemonic = process.env.MNEMONIC; const key = await mnemonicToKeyPair(mnemonic!.split(" ")); // open wallet v4 (notice the correct wallet version here) diff --git a/01-wallet/test/tonweb/step8.ts b/01-wallet/test/tonweb/step8.ts index ea54693..1691c67 100644 --- a/01-wallet/test/tonweb/step8.ts +++ b/01-wallet/test/tonweb/step8.ts @@ -6,8 +6,7 @@ import { mnemonicToKeyPair } from "tonweb-mnemonic"; import TonWeb from "tonweb"; async function main() { - // const mnemonic = process.env.MNEMONIC; // use your mnemonic phrase from .end file in the root of the project - const mnemonic = "memory album during buyer copper until arm forest identify race eyebrow bunker dawn phrase butter knock owner thumb click lottery catalog desk trial copper"; // your 24 secret words (replace ... with the rest of the words) + const mnemonic = process.env.MNEMONIC; const key = await mnemonicToKeyPair(mnemonic!.split(" ")); // initialize ton rpc client on testnet diff --git a/01-wallet/test/tonweb/step9.ts b/01-wallet/test/tonweb/step9.ts index ac2e7ec..afb7d12 100644 --- a/01-wallet/test/tonweb/step9.ts +++ b/01-wallet/test/tonweb/step9.ts @@ -6,8 +6,7 @@ import { mnemonicToKeyPair } from "tonweb-mnemonic"; import TonWeb from "tonweb"; async function main() { - // const mnemonic = process.env.MNEMONIC; // use your mnemonic phrase from .end file in the root of the project - const mnemonic = "memory album during buyer copper until arm forest identify race eyebrow bunker dawn phrase butter knock owner thumb click lottery catalog desk trial copper"; + const mnemonic = process.env.MNEMONIC; const key = await mnemonicToKeyPair(mnemonic!.split(" ")); // initialize ton rpc client on testnet diff --git a/02-contract/index.md b/02-contract/index.md index d6d0f84..dbbf652 100644 --- a/02-contract/index.md +++ b/02-contract/index.md @@ -166,7 +166,7 @@ The recommended way to interact with contracts is to create a small TypeScript c Use the following code in `wrappers/Counter.ts` to create the initial data cell for deployment: ```ts -import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core"; +import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core"; export default class Counter implements Contract { @@ -183,7 +183,7 @@ export default class Counter implements Contract { } ``` -Notice a few interesting things about this TypeScript code. First, it depends on the package [ton-core](https://www.npmjs.com/package/ton-core) instead of [ton](https://www.npmjs.com/package/ton), which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our `save_data()` FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function `contractAddress`. +Notice a few interesting things about this TypeScript code. First, it depends on the package [@ton/core](https://www.npmjs.com/package/@ton/core) instead of [ton](https://www.npmjs.com/package/ton), which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our `save_data()` FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function `contractAddress`. The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function `sendDeploy()` to `wrappers/Counter.ts` - this function will send the deployment message: @@ -226,8 +226,8 @@ network:testnet ```ts import * as fs from "fs"; import { getHttpEndpoint } from "@orbs-network/ton-access"; -import { mnemonicToWalletKey } from "ton-crypto"; -import { TonClient, Cell, WalletContractV4 } from "ton"; +import { mnemonicToWalletKey } from "@ton/crypto"; +import { TonClient, Cell, WalletContractV4 } from "@ton/ton"; import Counter from "../wrappers/Counter"; // this is the interface class from step 7 export async function run() { @@ -286,8 +286,8 @@ network:mainnet ```ts import * as fs from "fs"; import { getHttpEndpoint } from "@orbs-network/ton-access"; -import { mnemonicToWalletKey } from "ton-crypto"; -import { TonClient, Cell, WalletContractV4 } from "ton"; +import { mnemonicToWalletKey } from "@ton/crypto"; +import { TonClient, Cell, WalletContractV4 } from "@ton/ton"; import Counter from "../wrappers/Counter"; // this is the interface class from step 7 export async function run() { @@ -406,7 +406,7 @@ network:testnet --- ```ts import { getHttpEndpoint } from "@orbs-network/ton-access"; -import { TonClient, Address } from "ton"; +import { TonClient, Address } from "@ton/ton"; import Counter from "../wrappers/Counter"; // this is the interface class we just implemented export async function run() { @@ -432,7 +432,7 @@ network:mainnet --- ```ts import { getHttpEndpoint } from "@orbs-network/ton-access"; -import { TonClient, Address } from "ton"; +import { TonClient, Address } from "@ton/ton"; import Counter from "../wrappers/Counter"; // this is the interface class we just implemented export async function run() { @@ -501,8 +501,8 @@ network:testnet --- ```ts import { getHttpEndpoint } from "@orbs-network/ton-access"; -import { mnemonicToWalletKey } from "ton-crypto"; -import { TonClient, WalletContractV4, Address } from "ton"; +import { mnemonicToWalletKey } from "@ton/crypto"; +import { TonClient, Cell, WalletContractV4 } from "@ton/ton"; import Counter from "../wrappers/Counter"; // this is the interface class we just implemented export async function run() { @@ -553,8 +553,8 @@ network:mainnet --- ```ts import { getHttpEndpoint } from "@orbs-network/ton-access"; -import { mnemonicToWalletKey } from "ton-crypto"; -import { TonClient, WalletContractV4, Address } from "ton"; +import { mnemonicToWalletKey } from "@ton/crypto"; +import { TonClient, Cell, WalletContractV4 } from "@ton/ton"; import Counter from "../wrappers/Counter"; // this is the interface class we just implemented export async function run() { diff --git a/02-contract/test/step9.expected.txt b/02-contract/test/getCounter.expected.txt similarity index 100% rename from 02-contract/test/step9.expected.txt rename to 02-contract/test/getCounter.expected.txt diff --git a/02-contract/test/step9.ts b/02-contract/test/getCounter.ts similarity index 96% rename from 02-contract/test/step9.ts rename to 02-contract/test/getCounter.ts index 849f0b2..9d7f117 100644 --- a/02-contract/test/step9.ts +++ b/02-contract/test/getCounter.ts @@ -5,7 +5,7 @@ import { getHttpEndpoint } from "@orbs-network/ton-access"; import { TonClient, Address } from "@ton/ton"; import Counter from "./counter.step9"; // this is the interface class we just implemented -export async function main() { +export async function run() { // initialize ton rpc client on testnet const endpoint = await getHttpEndpoint({ network: "testnet" }); const client = new TonClient({ endpoint }); @@ -23,7 +23,7 @@ export async function main() { console.log("value:", counterValue >= 1000000000000n ? "more than 1T" : "less than 1T"); } -main() +run() function sleep(ms: number) { return new Promise(resolve => setTimeout(resolve, ms)); diff --git a/02-contract/test/index.sh b/02-contract/test/index.sh index 0ceb79d..8c63198 100755 --- a/02-contract/test/index.sh +++ b/02-contract/test/index.sh @@ -7,7 +7,7 @@ npm install @ton/ton @ton/core @ton/crypto npm install @orbs-network/ton-access npx func-js stdlib.fc counter.fc --boc counter.cell npx ts-node deploy.step8.ts > deploy.step8.output.txt -COUNTER_ADDRESS=`cut -d : -s -f 2 < deploy.step8.output.txt` npx ts-node step9.ts > step9.output.txt -diff step9.output.txt step9.expected.txt -COUNTER_ADDRESS=`cut -d : -s -f 2 < deploy.step8.output.txt` npx ts-node step10.ts > step10.output.txt -diff step10.output.txt step10.expected.txt \ No newline at end of file +COUNTER_ADDRESS=`cut -d : -s -f 2 < deploy.step8.output.txt` npx ts-node getCounter.ts > getCounter.output.txt +diff getCounter.output.txt getCounter.expected.txt +COUNTER_ADDRESS=`cut -d : -s -f 2 < deploy.step8.output.txt` npx ts-node sendIncrement.ts > sendIncrement.output.txt +diff sendIncrement.output.txt sendIncrement.expected.txt \ No newline at end of file diff --git a/02-contract/test/step10.expected.txt b/02-contract/test/sendIncrement.expected.txt similarity index 100% rename from 02-contract/test/step10.expected.txt rename to 02-contract/test/sendIncrement.expected.txt diff --git a/02-contract/test/step10.ts b/02-contract/test/sendIncrement.ts similarity index 98% rename from 02-contract/test/step10.ts rename to 02-contract/test/sendIncrement.ts index 81caeaf..5d2bc79 100644 --- a/02-contract/test/step10.ts +++ b/02-contract/test/sendIncrement.ts @@ -6,7 +6,7 @@ import { mnemonicToWalletKey } from "@ton/crypto"; import { TonClient, WalletContractV4, Address } from "@ton/ton"; import Counter from "./counter.step10"; // this is the interface class we just implemented -export async function main() { +export async function run() { // initialize ton rpc client on testnet const endpoint = await getHttpEndpoint({ network: "testnet" }); const client = new TonClient({ endpoint }); @@ -43,7 +43,7 @@ export async function main() { console.log("transaction confirmed!"); } -main() +run() function sleep(ms: number) { return new Promise(resolve => setTimeout(resolve, ms)); diff --git a/03-client/index.md b/03-client/index.md index 255afb9..1e04f9e 100644 --- a/03-client/index.md +++ b/03-client/index.md @@ -38,7 +38,7 @@ npm install We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal: ```console -npm install ton ton-core ton-crypto +npm install @ton/ton @ton/core @ton/crypto npm install @orbs-network/ton-access ``` @@ -209,7 +209,7 @@ import { useEffect, useState } from 'react'; import Counter from '../contracts/counter'; import { useTonClient } from './useTonClient'; import { useAsyncInitialize } from './useAsyncInitialize'; -import { Address, OpenedContract } from 'ton-core'; +import { Address, OpenedContract } from '@ton/core'; export function useCounterContract() { const client = useTonClient(); @@ -292,7 +292,7 @@ Create the file `src/hooks/useTonConnect.ts` with the following content: ```ts import { useTonConnectUI } from '@tonconnect/ui-react'; -import { Sender, SenderArguments } from 'ton-core'; +import { Sender, SenderArguments } from '@ton/core'; export function useTonConnect(): { sender: Sender; connected: boolean } { const [tonConnectUI] = useTonConnectUI(); @@ -327,7 +327,7 @@ import Counter from '../contracts/counter'; import { useTonClient } from './useTonClient'; import { useAsyncInitialize } from './useAsyncInitialize'; import { useTonConnect } from './useTonConnect'; -import { Address, OpenedContract } from 'ton-core'; +import { Address, OpenedContract } from '@ton/core'; export function useCounterContract() { const client = useTonClient(); diff --git a/04-testing/index.md b/04-testing/index.md index 5a541c1..7a44fee 100644 --- a/04-testing/index.md +++ b/04-testing/index.md @@ -19,7 +19,7 @@ Because testing is such as big deal in smart contract development, there's a sur 3. **Writing tests in FunC** - [toncli](https://github.com/disintar/toncli) is a command-line tool written in Python that runs on your machine and supports [debug](https://github.com/disintar/toncli/blob/master/docs/advanced/transaction_debug.md) and [unit tests](https://github.com/disintar/toncli/blob/master/docs/advanced/func_tests_new.md) for FunC contracts where the tests are also written in FunC ([example](https://github.com/BorysMinaiev/func-contest-1-tests-playground/blob/main/task-1/tests/test.fc)). -4. **Bare-bones TVM with Sandbox** - [Sandbox](https://github.com/ton-community/sandbox) is a bare-bones version of just the [TVM](https://ton-blockchain.github.io/docs/tvm.pdf) running on [WebAssembly](https://webassembly.org/) with a thin JavaScript wrapper that allows test interactions from TypeScript. +4. **Bare-bones TVM with Sandbox** - [Sandbox](https://github.com/ton-org/sandbox) is a bare-bones version of just the [TVM](https://ton-blockchain.github.io/docs/tvm.pdf) running on [WebAssembly](https://webassembly.org/) with a thin JavaScript wrapper that allows test interactions from TypeScript. 5. **Deploying beta contracts to mainnet** - This form of "testing in production" simply deploys alternative beta versions of your contracts to mainnet and uses real (not free) TON coin to play with them in a real environment. If you found a bug, you simply deploy new fixed beta versions and waste a little more money. @@ -76,10 +76,10 @@ module.exports = { And finally, run in terminal: ```console -npm install ton-core @ton-community/sandbox @ton-community/test-utils +npm install @ton/core @ton/sandbox @ton/test-utils ``` -This will install [Sandbox](https://github.com/ton-community/sandbox) and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated. +This will install [Sandbox](https://github.com/ton-org/sandbox) and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated. ## Step 2: Load our contract in a test @@ -104,8 +104,8 @@ Create the file `step2.spec.ts` with the following content: ```ts import * as fs from "fs"; -import { Cell } from "ton-core"; -import { Blockchain, SandboxContract, TreasuryContract } from "@ton-community/sandbox"; +import { Cell } from "@ton/core"; +import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox"; import Counter from "./counter"; // this is the interface class from tutorial 2 describe("Counter tests", () => { @@ -296,7 +296,7 @@ The console output should include something like this: We can see that the debug messages are printed when the test is running. When we send some TON coin explicitly to the contract (7.123 coins), we can see that the first debug print indeed shows the expected value of `msg_value`. Since the TVM doesn't support floating points, the number is represented internally as a large integer (with 9 decimals, meaning multiplied by 10^9). On the second test, when we send the increment op, we can see both debug prints showing. This is because this message also includes a small amount of coins for gas. -If you would like to see even more verbose log output from running your contracts, you can [increase the verbosity](https://github.com/ton-community/sandbox#viewing-logs) of the `blockchain` object after creating it in beforeEach: +If you would like to see even more verbose log output from running your contracts, you can [increase the verbosity](https://github.com/ton-org/sandbox#viewing-logs) of the `blockchain` object after creating it in beforeEach: ```ts blockchain.verbosity = { @@ -339,7 +339,7 @@ Ready to claim your reward? Simply scan the QR code below or click -

More Tutorials

+

Tutorials
diff --git a/docs/02-contract/index.html b/docs/02-contract/index.html index 512e671..e64a8e6 100644 --- a/docs/02-contract/index.html +++ b/docs/02-contract/index.html @@ -83,12 +83,12 @@

npm ton (JavaScript)

-

More Tutorials

+

Tutorials

@@ -206,7 +206,7 @@

Init arguments

Interface class

The recommended way to interact with contracts is to create a small TypeScript class that will implement the interaction interface with the contract. We're using the project structure created by Blueprint, but we're still working on low-level aspects. Use the following code in wrappers/Counter.ts to create the initial data cell for deployment:

-
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core";
+
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core";
 
 export default class Counter implements Contract {
 
@@ -222,7 +222,7 @@ 
Interface class

   constructor(readonly address: Address, readonly init?: { code: Cell, data: Cell }) {}
 }
 

-
Notice a few interesting things about this TypeScript code. First, it depends on the package ton-core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

+
Notice a few interesting things about this TypeScript code. First, it depends on the package @ton/core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

 
The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function sendDeploy() to wrappers/Counter.ts - this function will send the deployment message:

 
// export default class Counter implements Contract {
 
@@ -247,8 +247,8 @@ 
Step 8: Deploy the contract on-chain

 
Replace the current code in scripts/deployCounter.ts with a script that will use the interface class we have just written:

 
import * as fs from "fs";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, Cell, WalletContractV4 } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class from step 7
 
 export async function run() {
@@ -326,7 +326,7 @@ 
Executing the call

 
Calling a getter is free and does not cost gas. The reason is that this call is read-only, so it does not require consensus by the validators and is not stored in a block on-chain for all eternity like transaction are.

 
Let's create a new script called getCounter.ts in the scripts folder and use our shiny interface class to make the call. We're going to emulate a different developer interacting with our contract and since the contract is already deployed, they are likely to access it by address. Be sure to replace my deployed contract address with yours in the code below:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { TonClient, Address } from "ton";
+import { TonClient, Address } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -373,8 +373,8 @@ 
Interface class

 
Executing the send

 
The messages can be sent from any TON wallet, not necessarily the deployer wallet. Create a new script sendIncrement.ts in the scripts folder and use your wallet to fund the send:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, WalletContractV4, Address } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -543,7 +543,7 @@ 
Init arguments

 
Interface class

 
The recommended way to interact with contracts is to create a small TypeScript class that will implement the interaction interface with the contract. We're using the project structure created by Blueprint, but we're still working on low-level aspects.
 Use the following code in wrappers/Counter.ts to create the initial data cell for deployment:

-
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core";
+
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core";
 
 export default class Counter implements Contract {
 
@@ -559,7 +559,7 @@ 
Interface class

   constructor(readonly address: Address, readonly init?: { code: Cell, data: Cell }) {}
 }
 

-
Notice a few interesting things about this TypeScript code. First, it depends on the package ton-core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

+
Notice a few interesting things about this TypeScript code. First, it depends on the package @ton/core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

 
The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function sendDeploy() to wrappers/Counter.ts - this function will send the deployment message:

 
// export default class Counter implements Contract {
 
@@ -584,8 +584,8 @@ 
Step 8: Deploy the contract on-chain

 
Replace the current code in scripts/deployCounter.ts with a script that will use the interface class we have just written:

 
import * as fs from "fs";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, Cell, WalletContractV4 } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class from step 7
 
 export async function run() {
@@ -663,7 +663,7 @@ 
Executing the call

 
Calling a getter is free and does not cost gas. The reason is that this call is read-only, so it does not require consensus by the validators and is not stored in a block on-chain for all eternity like transaction are.

 
Let's create a new script called getCounter.ts in the scripts folder and use our shiny interface class to make the call. We're going to emulate a different developer interacting with our contract and since the contract is already deployed, they are likely to access it by address. Be sure to replace my deployed contract address with yours in the code below:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { TonClient, Address } from "ton";
+import { TonClient, Address } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -710,8 +710,8 @@ 
Interface class

 
Executing the send

 
The messages can be sent from any TON wallet, not necessarily the deployer wallet. Create a new script sendIncrement.ts in the scripts folder and use your wallet to fund the send:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, WalletContractV4, Address } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
diff --git a/docs/02-contract/mainnet-npmton.html b/docs/02-contract/mainnet-npmton.html
index d5a023e..4ca3bf6 100644
--- a/docs/02-contract/mainnet-npmton.html
+++ b/docs/02-contract/mainnet-npmton.html
@@ -94,7 +94,7 @@ 
Init arguments

 
Interface class

 
The recommended way to interact with contracts is to create a small TypeScript class that will implement the interaction interface with the contract. We're using the project structure created by Blueprint, but we're still working on low-level aspects.
 Use the following code in wrappers/Counter.ts to create the initial data cell for deployment:

-
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core";
+
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core";
 
 export default class Counter implements Contract {
 
@@ -110,7 +110,7 @@ 
Interface class

   constructor(readonly address: Address, readonly init?: { code: Cell, data: Cell }) {}
 }
 

-
Notice a few interesting things about this TypeScript code. First, it depends on the package ton-core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

+
Notice a few interesting things about this TypeScript code. First, it depends on the package @ton/core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

 
The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function sendDeploy() to wrappers/Counter.ts - this function will send the deployment message:

 
// export default class Counter implements Contract {
 
@@ -135,8 +135,8 @@ 
Step 8: Deploy the contract on-chain

 
Replace the current code in scripts/deployCounter.ts with a script that will use the interface class we have just written:

 
import * as fs from "fs";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, Cell, WalletContractV4 } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class from step 7
 
 export async function run() {
@@ -214,7 +214,7 @@ 
Executing the call

 
Calling a getter is free and does not cost gas. The reason is that this call is read-only, so it does not require consensus by the validators and is not stored in a block on-chain for all eternity like transaction are.

 
Let's create a new script called getCounter.ts in the scripts folder and use our shiny interface class to make the call. We're going to emulate a different developer interacting with our contract and since the contract is already deployed, they are likely to access it by address. Be sure to replace my deployed contract address with yours in the code below:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { TonClient, Address } from "ton";
+import { TonClient, Address } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -261,8 +261,8 @@ 
Interface class

 
Executing the send

 
The messages can be sent from any TON wallet, not necessarily the deployer wallet. Create a new script sendIncrement.ts in the scripts folder and use your wallet to fund the send:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, WalletContractV4, Address } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
diff --git a/docs/02-contract/mainnet-npmton.md b/docs/02-contract/mainnet-npmton.md
index 7655043..8bd0f7d 100644
--- a/docs/02-contract/mainnet-npmton.md
+++ b/docs/02-contract/mainnet-npmton.md
@@ -166,7 +166,7 @@ The recommended way to interact with contracts is to create a small TypeScript c
 Use the following code in `wrappers/Counter.ts` to create the initial data cell for deployment:
 
 ```ts
-import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core";
+import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core";
 
 export default class Counter implements Contract {
 
@@ -183,7 +183,7 @@ export default class Counter implements Contract {
 }
 ```
 
-Notice a few interesting things about this TypeScript code. First, it depends on the package [ton-core](https://www.npmjs.com/package/ton-core) instead of [ton](https://www.npmjs.com/package/ton), which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our `save_data()` FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function `contractAddress`.
+Notice a few interesting things about this TypeScript code. First, it depends on the package [@ton/core](https://www.npmjs.com/package/@ton/core) instead of [ton](https://www.npmjs.com/package/ton), which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our `save_data()` FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function `contractAddress`.
 
 The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function `sendDeploy()` to `wrappers/Counter.ts` - this function will send the deployment message:
 
@@ -223,8 +223,8 @@ Replace the current code in `scripts/deployCounter.ts` with a script that will u
 ```ts
 import * as fs from "fs";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, Cell, WalletContractV4 } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class from step 7
 
 export async function run() {
@@ -324,7 +324,7 @@ Let's create a new script called `getCounter.ts` in the `scripts` folder and use
 
 ```ts
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { TonClient, Address } from "ton";
+import { TonClient, Address } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -388,8 +388,8 @@ The messages can be sent from any TON wallet, not necessarily the deployer walle
 
 ```ts
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, WalletContractV4, Address } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
diff --git a/docs/02-contract/testnet-npmton.html b/docs/02-contract/testnet-npmton.html
index eaf8644..6ddde3d 100644
--- a/docs/02-contract/testnet-npmton.html
+++ b/docs/02-contract/testnet-npmton.html
@@ -94,7 +94,7 @@ 
Init arguments

 
Interface class

 
The recommended way to interact with contracts is to create a small TypeScript class that will implement the interaction interface with the contract. We're using the project structure created by Blueprint, but we're still working on low-level aspects.
 Use the following code in wrappers/Counter.ts to create the initial data cell for deployment:

-
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core";
+
import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core";
 
 export default class Counter implements Contract {
 
@@ -110,7 +110,7 @@ 
Interface class

   constructor(readonly address: Address, readonly init?: { code: Cell, data: Cell }) {}
 }
 

-
Notice a few interesting things about this TypeScript code. First, it depends on the package ton-core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

+
Notice a few interesting things about this TypeScript code. First, it depends on the package @ton/core instead of ton, which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our save_data() FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function contractAddress.

 
The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function sendDeploy() to wrappers/Counter.ts - this function will send the deployment message:

 
// export default class Counter implements Contract {
 
@@ -135,8 +135,8 @@ 
Step 8: Deploy the contract on-chain

 
Replace the current code in scripts/deployCounter.ts with a script that will use the interface class we have just written:

 
import * as fs from "fs";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, Cell, WalletContractV4 } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class from step 7
 
 export async function run() {
@@ -214,7 +214,7 @@ 
Executing the call

 
Calling a getter is free and does not cost gas. The reason is that this call is read-only, so it does not require consensus by the validators and is not stored in a block on-chain for all eternity like transaction are.

 
Let's create a new script called getCounter.ts in the scripts folder and use our shiny interface class to make the call. We're going to emulate a different developer interacting with our contract and since the contract is already deployed, they are likely to access it by address. Be sure to replace my deployed contract address with yours in the code below:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { TonClient, Address } from "ton";
+import { TonClient, Address } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -261,8 +261,8 @@ 
Interface class

 
Executing the send

 
The messages can be sent from any TON wallet, not necessarily the deployer wallet. Create a new script sendIncrement.ts in the scripts folder and use your wallet to fund the send:

 
import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, WalletContractV4, Address } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
diff --git a/docs/02-contract/testnet-npmton.md b/docs/02-contract/testnet-npmton.md
index b2c438f..fc804b0 100644
--- a/docs/02-contract/testnet-npmton.md
+++ b/docs/02-contract/testnet-npmton.md
@@ -166,7 +166,7 @@ The recommended way to interact with contracts is to create a small TypeScript c
 Use the following code in `wrappers/Counter.ts` to create the initial data cell for deployment:
 
 ```ts
-import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "ton-core";
+import { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell } from "@ton/core";
 
 export default class Counter implements Contract {
 
@@ -183,7 +183,7 @@ export default class Counter implements Contract {
 }
 ```
 
-Notice a few interesting things about this TypeScript code. First, it depends on the package [ton-core](https://www.npmjs.com/package/ton-core) instead of [ton](https://www.npmjs.com/package/ton), which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our `save_data()` FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function `contractAddress`.
+Notice a few interesting things about this TypeScript code. First, it depends on the package [@ton/core](https://www.npmjs.com/package/@ton/core) instead of [ton](https://www.npmjs.com/package/ton), which contains a small subset of base types and is therefore slower to change - an important feature when building a stable interface for our contract. Second, the code that creates the data cell mimics the FunC API and is almost identical to our `save_data()` FunC function. Third, we can see the derivation of the contract address from the code cell and data cell using the function `contractAddress`.
 
 The actual deployment involves sending the first message that will cause our contract to be deployed. We can piggyback any message that is directed towards our contract. This can even be the increment message with op #1, but we will do something simpler. We will just send some TON coins to our contract (an empty message) and piggyback that. Let's make this part of our interface. Add the function `sendDeploy()` to `wrappers/Counter.ts` - this function will send the deployment message:
 
@@ -223,8 +223,8 @@ Replace the current code in `scripts/deployCounter.ts` with a script that will u
 ```ts
 import * as fs from "fs";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, Cell, WalletContractV4 } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class from step 7
 
 export async function run() {
@@ -324,7 +324,7 @@ Let's create a new script called `getCounter.ts` in the `scripts` folder and use
 
 ```ts
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { TonClient, Address } from "ton";
+import { TonClient, Address } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
@@ -388,8 +388,8 @@ The messages can be sent from any TON wallet, not necessarily the deployer walle
 
 ```ts
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-import { mnemonicToWalletKey } from "ton-crypto";
-import { TonClient, WalletContractV4, Address } from "ton";
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { TonClient, Cell, WalletContractV4 } from "@ton/ton";
 import Counter from "../wrappers/Counter"; // this is the interface class we just implemented
 
 export async function run() {
diff --git a/docs/03-client/index.html b/docs/03-client/index.html
index 18a8265..1181797 100644
--- a/docs/03-client/index.html
+++ b/docs/03-client/index.html
@@ -83,12 +83,12 @@ 
npm ton (JavaScript)
-

More Tutorials

+

Tutorials

@@ -131,7 +131,7 @@

Step 3: Set up the project

npm install

We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal:

-
npm install ton ton-core ton-crypto
+
npm install @ton/ton @ton/core @ton/crypto
 npm install @orbs-network/ton-access
 

 
Last but not least, we will need to overcome ton library's reliance on Nodejs Buffer that isn't available in the browser. We can do that by installing a polyfill. Run the following in terminal:

@@ -233,7 +233,7 @@ 
Step 6: Read the counter value fro
 import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -302,7 +302,7 @@ 
Step 7: Increment the counter on-chain<
 
Before starting, we're going to add another hook that will generate a sender object from the TON Connect interface. This sender represents the connected wallet and will allow us to send transactions on their behalf. While we're at it, we'll also expose the wallet connection state so we can alter the UI accordingly.

 
Create the file src/hooks/useTonConnect.ts with the following content:

 
import { useTonConnectUI } from '@tonconnect/ui-react';
-import { Sender, SenderArguments } from 'ton-core';
+import { Sender, SenderArguments } from '@ton/core';
 
 export function useTonConnect(): { sender: Sender; connected: boolean } {
   const [tonConnectUI] = useTonConnectUI();
@@ -333,7 +333,7 @@ 
Step 7: Increment the counter on-chain<
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
 import { useTonConnect } from './useTonConnect';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -599,7 +599,7 @@ 
Step 3: Set up the project

 npm install
 

 
We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal:

-
npm install ton ton-core ton-crypto
+
npm install @ton/ton @ton/core @ton/crypto
 npm install @orbs-network/ton-access
 

 
Last but not least, we will need to overcome ton library's reliance on Nodejs Buffer that isn't available in the browser. We can do that by installing a polyfill. Run the following in terminal:

@@ -701,7 +701,7 @@ 
Step 6: Read the counter value fro
 import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -770,7 +770,7 @@ 
Step 7: Increment the counter on-chain<
 
Before starting, we're going to add another hook that will generate a sender object from the TON Connect interface. This sender represents the connected wallet and will allow us to send transactions on their behalf. While we're at it, we'll also expose the wallet connection state so we can alter the UI accordingly.

 
Create the file src/hooks/useTonConnect.ts with the following content:

 
import { useTonConnectUI } from '@tonconnect/ui-react';
-import { Sender, SenderArguments } from 'ton-core';
+import { Sender, SenderArguments } from '@ton/core';
 
 export function useTonConnect(): { sender: Sender; connected: boolean } {
   const [tonConnectUI] = useTonConnectUI();
@@ -801,7 +801,7 @@ 
Step 7: Increment the counter on-chain<
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
 import { useTonConnect } from './useTonConnect';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
diff --git a/docs/03-client/mainnet-npmton.html b/docs/03-client/mainnet-npmton.html
index b438c23..ff5604e 100644
--- a/docs/03-client/mainnet-npmton.html
+++ b/docs/03-client/mainnet-npmton.html
@@ -19,7 +19,7 @@ 
Step 3: Set up the project

 npm install
 

 
We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal:

-
npm install ton ton-core ton-crypto
+
npm install @ton/ton @ton/core @ton/crypto
 npm install @orbs-network/ton-access
 

 
Last but not least, we will need to overcome ton library's reliance on Nodejs Buffer that isn't available in the browser. We can do that by installing a polyfill. Run the following in terminal:

@@ -121,7 +121,7 @@ 
Step 6: Read the counter value fro
 import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -190,7 +190,7 @@ 
Step 7: Increment the counter on-chain<
 
Before starting, we're going to add another hook that will generate a sender object from the TON Connect interface. This sender represents the connected wallet and will allow us to send transactions on their behalf. While we're at it, we'll also expose the wallet connection state so we can alter the UI accordingly.

 
Create the file src/hooks/useTonConnect.ts with the following content:

 
import { useTonConnectUI } from '@tonconnect/ui-react';
-import { Sender, SenderArguments } from 'ton-core';
+import { Sender, SenderArguments } from '@ton/core';
 
 export function useTonConnect(): { sender: Sender; connected: boolean } {
   const [tonConnectUI] = useTonConnectUI();
@@ -221,7 +221,7 @@ 
Step 7: Increment the counter on-chain<
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
 import { useTonConnect } from './useTonConnect';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
diff --git a/docs/03-client/mainnet-npmton.md b/docs/03-client/mainnet-npmton.md
index b3b9895..8d12f33 100644
--- a/docs/03-client/mainnet-npmton.md
+++ b/docs/03-client/mainnet-npmton.md
@@ -38,7 +38,7 @@ npm install
 We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal:
 
 ```console
-npm install ton ton-core ton-crypto
+npm install @ton/ton @ton/core @ton/crypto
 npm install @orbs-network/ton-access
 ```
 
@@ -184,7 +184,7 @@ import { useEffect, useState } from 'react';
 import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -267,7 +267,7 @@ Create the file `src/hooks/useTonConnect.ts` with the following content:
 
 ```ts
 import { useTonConnectUI } from '@tonconnect/ui-react';
-import { Sender, SenderArguments } from 'ton-core';
+import { Sender, SenderArguments } from '@ton/core';
 
 export function useTonConnect(): { sender: Sender; connected: boolean } {
   const [tonConnectUI] = useTonConnectUI();
@@ -302,7 +302,7 @@ import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
 import { useTonConnect } from './useTonConnect';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
diff --git a/docs/03-client/testnet-npmton.html b/docs/03-client/testnet-npmton.html
index 3b4a706..6fda009 100644
--- a/docs/03-client/testnet-npmton.html
+++ b/docs/03-client/testnet-npmton.html
@@ -19,7 +19,7 @@ 
Step 3: Set up the project

 npm install
 

 
We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal:

-
npm install ton ton-core ton-crypto
+
npm install @ton/ton @ton/core @ton/crypto
 npm install @orbs-network/ton-access
 

 
Last but not least, we will need to overcome ton library's reliance on Nodejs Buffer that isn't available in the browser. We can do that by installing a polyfill. Run the following in terminal:

@@ -121,7 +121,7 @@ 
Step 6: Read the counter value fro
 import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -190,7 +190,7 @@ 
Step 7: Increment the counter on-chain<
 
Before starting, we're going to add another hook that will generate a sender object from the TON Connect interface. This sender represents the connected wallet and will allow us to send transactions on their behalf. While we're at it, we'll also expose the wallet connection state so we can alter the UI accordingly.

 
Create the file src/hooks/useTonConnect.ts with the following content:

 
import { useTonConnectUI } from '@tonconnect/ui-react';
-import { Sender, SenderArguments } from 'ton-core';
+import { Sender, SenderArguments } from '@ton/core';
 
 export function useTonConnect(): { sender: Sender; connected: boolean } {
   const [tonConnectUI] = useTonConnectUI();
@@ -221,7 +221,7 @@ 
Step 7: Increment the counter on-chain<
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
 import { useTonConnect } from './useTonConnect';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
diff --git a/docs/03-client/testnet-npmton.md b/docs/03-client/testnet-npmton.md
index 54b0fbe..9b13b0b 100644
--- a/docs/03-client/testnet-npmton.md
+++ b/docs/03-client/testnet-npmton.md
@@ -38,7 +38,7 @@ npm install
 We will need to install a few more packages that will allow us to interact with TON Blockchain. We've seen these packages in action in the previous tutorial. Run the following in terminal:
 
 ```console
-npm install ton ton-core ton-crypto
+npm install @ton/ton @ton/core @ton/crypto
 npm install @orbs-network/ton-access
 ```
 
@@ -184,7 +184,7 @@ import { useEffect, useState } from 'react';
 import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
@@ -267,7 +267,7 @@ Create the file `src/hooks/useTonConnect.ts` with the following content:
 
 ```ts
 import { useTonConnectUI } from '@tonconnect/ui-react';
-import { Sender, SenderArguments } from 'ton-core';
+import { Sender, SenderArguments } from '@ton/core';
 
 export function useTonConnect(): { sender: Sender; connected: boolean } {
   const [tonConnectUI] = useTonConnectUI();
@@ -302,7 +302,7 @@ import Counter from '../contracts/counter';
 import { useTonClient } from './useTonClient';
 import { useAsyncInitialize } from './useAsyncInitialize';
 import { useTonConnect } from './useTonConnect';
-import { Address, OpenedContract } from 'ton-core';
+import { Address, OpenedContract } from '@ton/core';
 
 export function useCounterContract() {
   const client = useTonClient();
diff --git a/docs/04-testing/index.html b/docs/04-testing/index.html
index e302ccc..2b2969f 100644
--- a/docs/04-testing/index.html
+++ b/docs/04-testing/index.html
@@ -50,12 +50,12 @@ 
npm ton (JavaScript)
-

More Tutorials

+

Tutorials

@@ -88,7 +88,7 @@

Oh so many ways to test

  • Deploying your contract to testnet - Testnet is a live alternative instance of the entire TON Blockchain where TON coin isn't the real deal and is free to get. This instance is obviously not as secure as mainnet, but offers an interesting staging environment where you can play.

  • Local blockchain with MyLocalTon - MyLocalTon is a Java-based desktop executable that runs a personal local instance of TON Blockchain on your machine that you can deploy contracts to and interact with. Another way to run a local private TON network is using Kubernetes with ton-k8s.

  • Writing tests in FunC - toncli is a command-line tool written in Python that runs on your machine and supports debug and unit tests for FunC contracts where the tests are also written in FunC (example).

    • -

  • Bare-bones TVM with Sandbox - Sandbox is a bare-bones version of just the TVM running on WebAssembly with a thin JavaScript wrapper that allows test interactions from TypeScript.

    • +

  • Bare-bones TVM with Sandbox - Sandbox is a bare-bones version of just the TVM running on WebAssembly with a thin JavaScript wrapper that allows test interactions from TypeScript.

  • Deploying beta contracts to mainnet - This form of "testing in production" simply deploys alternative beta versions of your contracts to mainnet and uses real (not free) TON coin to play with them in a real environment. If you found a bug, you simply deploy new fixed beta versions and waste a little more money.

    • So which method should you choose? You definitely don't need all of them.

    @@ -125,9 +125,9 @@

    Step 1: Set up the project

    };

    And finally, run in terminal:

    -
    npm install ton-core @ton-community/sandbox @ton-community/test-utils
+
    npm install @ton/core @ton/sandbox @ton/test-utils
 
    
-
    This will install Sandbox and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated.
    
+
    This will install Sandbox and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated.
    
 
    Step 2: Load our contract in a test
    
 
    Quick reminder, in tutorial 2, we compiled our Counter smart contract in step 6 and generated the file counter.cell which contains the TVM bytecode for our contract (code cell). In step 7, before deploying the contract, we initialized its persistent storage (data cell). Then, we created the TypeScript interface class counter.ts that combines the two to deploy our contract.
    
 
    Dig into your completed tutorial 2 and copy both counter.cell (also available here) and counter.ts (also available here) to the project root.
    
@@ -141,8 +141,8 @@ 
    Step 2: Load our contract in a test
    
 
    Before we start writing tests, let's create our test skeleton. In the skeleton, before each test starts, we'll initialize a fresh instance of the entire blockchain. This instance will require a wallet with enough TON for all our gas needs (we call this a "treasury") and a deployed version of the Counter.
    
 
    Create the file step2.spec.ts with the following content:
    
 
    import * as fs from "fs";
-import { Cell } from "ton-core";
-import { Blockchain, SandboxContract, TreasuryContract } from "@ton-community/sandbox";
+import { Cell } from "@ton/core";
+import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
 import Counter from "./counter"; // this is the interface class from tutorial 2
 
 describe("Counter tests", () => {
@@ -278,7 +278,7 @@ 
    Step 5: Debug by dumping variables
    
     #DEBUG#: increment received
 
    
 
    We can see that the debug messages are printed when the test is running. When we send some TON coin explicitly to the contract (7.123 coins), we can see that the first debug print indeed shows the expected value of msg_value. Since the TVM doesn't support floating points, the number is represented internally as a large integer (with 9 decimals, meaning multiplied by 10^9). On the second test, when we send the increment op, we can see both debug prints showing. This is because this message also includes a small amount of coins for gas.
    
-
    If you would like to see even more verbose log output from running your contracts, you can increase the verbosity of the blockchain object after creating it in beforeEach:
    
+
    If you would like to see even more verbose log output from running your contracts, you can increase the verbosity of the blockchain object after creating it in beforeEach:
    
 
    blockchain.verbosity = {
   print: true,
   blockchainLogs: true,
@@ -306,7 +306,7 @@ 
    Reward
    
   QR-code
    
 
    Conclusion
    
 
    For your convenience, all the code in this tutorial is available in executable form here.
    
-
    In this tutorial we created our project skeleton manually, mostly so we can understand what happens under the hood. When creating a new contract project, you can have an excellent skeleton created automatically by an awesome dev tool called Blueprint. To create a new contract project with Blueprint, run in terminal and follow the on-screen instructions:
    
+
    In this tutorial we created our project skeleton manually, mostly so we can understand what happens under the hood. When creating a new contract project, you can have an excellent skeleton created automatically by an awesome dev tool called Blueprint. To create a new contract project with Blueprint, run in terminal and follow the on-screen instructions:
    
 
    npm create ton@latest
 
    
 
    If you found a mistake in this tutorial, please submit a PR and help us fix it. This tutorial platform is fully open source and available on https://github.com/ton-community/tutorials.
    
diff --git a/docs/04-testing/npmton.html b/docs/04-testing/npmton.html
index df07244..dccbb91 100644
--- a/docs/04-testing/npmton.html
+++ b/docs/04-testing/npmton.html
@@ -9,7 +9,7 @@ 
    Oh so many ways to test
    
 
  • Deploying your contract to testnet - Testnet is a live alternative instance of the entire TON Blockchain where TON coin isn't the real deal and is free to get. This instance is obviously not as secure as mainnet, but offers an interesting staging environment where you can play.
    • 
 
  • Local blockchain with MyLocalTon - MyLocalTon is a Java-based desktop executable that runs a personal local instance of TON Blockchain on your machine that you can deploy contracts to and interact with. Another way to run a local private TON network is using Kubernetes with ton-k8s.
    • 
 
  • Writing tests in FunC - toncli is a command-line tool written in Python that runs on your machine and supports debug and unit tests for FunC contracts where the tests are also written in FunC (example).
    • 
-
  • Bare-bones TVM with Sandbox - Sandbox is a bare-bones version of just the TVM running on WebAssembly with a thin JavaScript wrapper that allows test interactions from TypeScript.
    • 
+
  • Bare-bones TVM with Sandbox - Sandbox is a bare-bones version of just the TVM running on WebAssembly with a thin JavaScript wrapper that allows test interactions from TypeScript.
    • 
 
  • Deploying beta contracts to mainnet - This form of "testing in production" simply deploys alternative beta versions of your contracts to mainnet and uses real (not free) TON coin to play with them in a real environment. If you found a bug, you simply deploy new fixed beta versions and waste a little more money.
    • 
 
 
    So which method should you choose? You definitely don't need all of them.
    
@@ -46,9 +46,9 @@ 
    Step 1: Set up the project
    
 };
 
    
 
    And finally, run in terminal:
    
-
    npm install ton-core @ton-community/sandbox @ton-community/test-utils
+
    npm install @ton/core @ton/sandbox @ton/test-utils
 
    
-
    This will install Sandbox and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated.
    
+
    This will install Sandbox and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated.
    
 
    Step 2: Load our contract in a test
    
 
    Quick reminder, in tutorial 2, we compiled our Counter smart contract in step 6 and generated the file counter.cell which contains the TVM bytecode for our contract (code cell). In step 7, before deploying the contract, we initialized its persistent storage (data cell). Then, we created the TypeScript interface class counter.ts that combines the two to deploy our contract.
    
 
    Dig into your completed tutorial 2 and copy both counter.cell (also available here) and counter.ts (also available here) to the project root.
    
@@ -62,8 +62,8 @@ 
    Step 2: Load our contract in a test
    
 
    Before we start writing tests, let's create our test skeleton. In the skeleton, before each test starts, we'll initialize a fresh instance of the entire blockchain. This instance will require a wallet with enough TON for all our gas needs (we call this a "treasury") and a deployed version of the Counter.
    
 
    Create the file step2.spec.ts with the following content:
    
 
    import * as fs from "fs";
-import { Cell } from "ton-core";
-import { Blockchain, SandboxContract, TreasuryContract } from "@ton-community/sandbox";
+import { Cell } from "@ton/core";
+import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
 import Counter from "./counter"; // this is the interface class from tutorial 2
 
 describe("Counter tests", () => {
@@ -199,7 +199,7 @@ 
    Step 5: Debug by dumping variables
    
     #DEBUG#: increment received
 
    
 
    We can see that the debug messages are printed when the test is running. When we send some TON coin explicitly to the contract (7.123 coins), we can see that the first debug print indeed shows the expected value of msg_value. Since the TVM doesn't support floating points, the number is represented internally as a large integer (with 9 decimals, meaning multiplied by 10^9). On the second test, when we send the increment op, we can see both debug prints showing. This is because this message also includes a small amount of coins for gas.
    
-
    If you would like to see even more verbose log output from running your contracts, you can increase the verbosity of the blockchain object after creating it in beforeEach:
    
+
    If you would like to see even more verbose log output from running your contracts, you can increase the verbosity of the blockchain object after creating it in beforeEach:
    
 
    blockchain.verbosity = {
   print: true,
   blockchainLogs: true,
@@ -227,7 +227,7 @@ 
    Reward
    
   QR-code
    
 
    Conclusion
    
 
    For your convenience, all the code in this tutorial is available in executable form here.
    
-
    In this tutorial we created our project skeleton manually, mostly so we can understand what happens under the hood. When creating a new contract project, you can have an excellent skeleton created automatically by an awesome dev tool called Blueprint. To create a new contract project with Blueprint, run in terminal and follow the on-screen instructions:
    
+
    In this tutorial we created our project skeleton manually, mostly so we can understand what happens under the hood. When creating a new contract project, you can have an excellent skeleton created automatically by an awesome dev tool called Blueprint. To create a new contract project with Blueprint, run in terminal and follow the on-screen instructions:
    
 
    npm create ton@latest
 
    
 
    If you found a mistake in this tutorial, please submit a PR and help us fix it. This tutorial platform is fully open source and available on https://github.com/ton-community/tutorials.
    
diff --git a/docs/04-testing/npmton.md b/docs/04-testing/npmton.md
index 5a541c1..7a44fee 100644
--- a/docs/04-testing/npmton.md
+++ b/docs/04-testing/npmton.md
@@ -19,7 +19,7 @@ Because testing is such as big deal in smart contract development, there's a sur
 
 3. **Writing tests in FunC** - [toncli](https://github.com/disintar/toncli) is a command-line tool written in Python that runs on your machine and supports [debug](https://github.com/disintar/toncli/blob/master/docs/advanced/transaction_debug.md) and [unit tests](https://github.com/disintar/toncli/blob/master/docs/advanced/func_tests_new.md) for FunC contracts where the tests are also written in FunC ([example](https://github.com/BorysMinaiev/func-contest-1-tests-playground/blob/main/task-1/tests/test.fc)).
 
-4. **Bare-bones TVM with Sandbox** - [Sandbox](https://github.com/ton-community/sandbox) is a bare-bones version of just the [TVM](https://ton-blockchain.github.io/docs/tvm.pdf) running on [WebAssembly](https://webassembly.org/) with a thin JavaScript wrapper that allows test interactions from TypeScript.
+4. **Bare-bones TVM with Sandbox** - [Sandbox](https://github.com/ton-org/sandbox) is a bare-bones version of just the [TVM](https://ton-blockchain.github.io/docs/tvm.pdf) running on [WebAssembly](https://webassembly.org/) with a thin JavaScript wrapper that allows test interactions from TypeScript.
 
 5. **Deploying beta contracts to mainnet** - This form of "testing in production" simply deploys alternative beta versions of your contracts to mainnet and uses real (not free) TON coin to play with them in a real environment. If you found a bug, you simply deploy new fixed beta versions and waste a little more money.
 
@@ -76,10 +76,10 @@ module.exports = {
 And finally, run in terminal:
 
 ```console
-npm install ton-core @ton-community/sandbox @ton-community/test-utils
+npm install @ton/core @ton/sandbox @ton/test-utils
 ```
 
-This will install [Sandbox](https://github.com/ton-community/sandbox) and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated.
+This will install [Sandbox](https://github.com/ton-org/sandbox) and its dependencies. Sandbox is our magical library that will emulate TON Blockchain locally by running a bare-bones version of the TVM in process. This will guarantee that our tests will be blazingly fast and completely isolated.
 
 ## Step 2: Load our contract in a test
 
@@ -104,8 +104,8 @@ Create the file `step2.spec.ts` with the following content:
 
 ```ts
 import * as fs from "fs";
-import { Cell } from "ton-core";
-import { Blockchain, SandboxContract, TreasuryContract } from "@ton-community/sandbox";
+import { Cell } from "@ton/core";
+import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
 import Counter from "./counter"; // this is the interface class from tutorial 2
 
 describe("Counter tests", () => {
@@ -296,7 +296,7 @@ The console output should include something like this:
 
 We can see that the debug messages are printed when the test is running. When we send some TON coin explicitly to the contract (7.123 coins), we can see that the first debug print indeed shows the expected value of `msg_value`. Since the TVM doesn't support floating points, the number is represented internally as a large integer (with 9 decimals, meaning multiplied by 10^9). On the second test, when we send the increment op, we can see both debug prints showing. This is because this message also includes a small amount of coins for gas.
 
-If you would like to see even more verbose log output from running your contracts, you can [increase the verbosity](https://github.com/ton-community/sandbox#viewing-logs) of the `blockchain` object after creating it in beforeEach:
+If you would like to see even more verbose log output from running your contracts, you can [increase the verbosity](https://github.com/ton-org/sandbox#viewing-logs) of the `blockchain` object after creating it in beforeEach:
 
 ```ts
 blockchain.verbosity = {
@@ -339,7 +339,7 @@ Ready to claim your reward? Simply scan the QR code below or click  document.querySelectorAll(".post");
+const getTutorialLinks = () => document.querySelectorAll("[data=tutorial-link]")
+
+const setSelectedTutorialLink = () => {
+  getTutorialLinks().forEach((tutorialLink) => {
+    if(tutorialLink.href === window.location.href) {
+      tutorialLink.classList.add("selected");
+    }
+  });
+};
 
 const onOutsideClick = (container) => {
   document.addEventListener("click", (event) => {
@@ -129,6 +138,7 @@ const updateCombination = () => {
 };
 
 window.onload = () => {
+  setSelectedTutorialLink();
   updateCombination();
   getSelectBoxes().forEach((selectbox) => {
     const selected = selectbox.querySelector(".selectbox-selected");
diff --git a/docs/assets/styles.css b/docs/assets/styles.css
index d8a1942..32c680b 100644
--- a/docs/assets/styles.css
+++ b/docs/assets/styles.css
@@ -24,6 +24,11 @@ a {
   border-bottom: 0.75px solid rgba(0, 136, 204, 0.6);
 }
 
+a.selected {
+  text-decoration: underline;
+  pointer-events: none;
+}
+
 /* http://meyerweb.com/eric/tools/css/reset/ 
    v2.0 | 20110126
    License: none (public domain)
diff --git a/docs/assets/styles.css.map b/docs/assets/styles.css.map
index 96bd969..0ec523d 100644
--- a/docs/assets/styles.css.map
+++ b/docs/assets/styles.css.map
@@ -1 +1 @@
-{"version":3,"sourceRoot":"","sources":["../../styles.scss"],"names":[],"mappings":"AACQ;AAMR;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE,WAfW;EAgBX;;;AAEF;EACE;EACA;;;AAGF;EACE,OArBW;EAsBX;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAiFE;EACA;EACA;EACA;EACA;EACA;;;AAEF;AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAWE;;;AAEF;EACE;EACE;;;AAEJ;AAAA;EAEE;;;AAEF;AAAA;EAEE;;;AAEF;AAAA;AAAA;AAAA;EAIE;EACA;;;AAEF;EACE;EACA;;;AAGF;EACE;;;AAGF;EACE,aArKU;EAsKV,OApKW;;;AAuKb;EACE;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;AAEA;EACE;EACA;EACA;EACA;EACA,YA3LM;EA4LN;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;;AAGJ;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;;AACA;EACE;;AAGJ;EACE;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEF;EACE;;AAGJ;AAAA;AAAA;EACE;EACA;;AAEF;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;;AAEF;AAAA;EAEE;EACA;EAEA;EACA;EACA;;AACA;AAAA;EAEE;EACA;EACA;EACA;;AAIJ;EACE;;AAEF;EACE;;AAIN;EACE;;AACA;EACE;EACA;EACA;EACA;;;AAKN;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;AAEE;EACE;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAIN;EACE;EACA;;AACA;EACE;;AAGJ;EACE;;AAEF;EACE;;AAEF;EACE;EACA;;AAEF;EACE;;AAEF;EACE;;AAEF;EACE;;AAEF;EAEE;;AAEF;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;;AAEF;EACE,OAxZO;EAyZP;;AACA;EACE;EACA;;AAON;EACE,YAraM;EAsaN;EACA;EACA;EAEA;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA,YAnbM;EAobN;EACA;;AACA;EACE;;AAEF;EACE;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEF;EACE,YArdE;EAudF;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAIF;EACE;;AAIN;EACE;EACA;EAEA;;AAEF;EACE;;AAEF;EACE;;AAEF;EACE;;AAEF;EACE;EACA;EACA;EACA;;AAGA;EACE;;;AAMR;EACE;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;;;AAGF;EACE,OAhiBW;EAiiBX;;;AAGF;EACE;EACA;EACA;EACA;;AACA;EACE;;AAEF;EACE;EACA;EACA;EACA;;;AAIJ;EACE,WAtjBW;EAujBX;EACA;EACA;EAEA;;;AAEF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE,YAjlBQ;EAklBR;EACA;;;AAGF;EACE;EACA;;AACA;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;;AACA;EACE;EACA;;;AAKN;EACE;EACA;;AACA;EACE;EACA;;;AAIJ;EACE;IACE;;EAEF;IACE;;EAEF;IACE;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;;EAEF;IACE;IACA;;EAGA;IACE;IACA;;EAEF;IACE;IACA;IACA;;EAEF;IACE;IACA","file":"styles.css"}
\ No newline at end of file
+{"version":3,"sourceRoot":"","sources":["../../styles.scss"],"names":[],"mappings":"AACQ;AAMR;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE,WAfW;EAgBX;;;AAEF;EACE;EACA;;;AAGF;EACE,OArBW;EAsBX;;;AAGF;EACE;EACA;;;AAGF;AAAA;AAAA;AAAA;AAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAiFE;EACA;EACA;EACA;EACA;EACA;;;AAEF;AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAWE;;;AAEF;EACE;EACE;;;AAEJ;AAAA;EAEE;;;AAEF;AAAA;EAEE;;;AAEF;AAAA;AAAA;AAAA;EAIE;EACA;;;AAEF;EACE;EACA;;;AAGF;EACE;;;AAGF;EACE,aA1KU;EA2KV,OAzKW;;;AA4Kb;EACE;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;AAEA;EACE;EACA;EACA;EACA;EACA,YAhMM;EAiMN;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;;AAGJ;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;;AACA;EACE;;AAGJ;EACE;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEF;EACE;;AAGJ;AAAA;AAAA;EACE;EACA;;AAEF;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;;AAEF;AAAA;EAEE;EACA;EAEA;EACA;EACA;;AACA;AAAA;EAEE;EACA;EACA;EACA;;AAIJ;EACE;;AAEF;EACE;;AAIN;EACE;;AACA;EACE;EACA;EACA;EACA;;;AAKN;EACE;EACA;EACA;EACA;EACA;EACA;;;AAEF;EACE;EACA;EACA;;AAEE;EACE;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAIN;EACE;EACA;;AACA;EACE;;AAGJ;EACE;;AAEF;EACE;;AAEF;EACE;EACA;;AAEF;EACE;;AAEF;EACE;;AAEF;EACE;;AAEF;EAEE;;AAEF;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;;AAEF;EACE,OA7ZO;EA8ZP;;AACA;EACE;EACA;;AAON;EACE,YA1aM;EA2aN;EACA;EACA;EAEA;EACA;EACA;EACA;;AAEF;EACE;EACA;EACA;EACA,YAxbM;EAybN;EACA;;AACA;EACE;;AAEF;EACE;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEF;EACE,YA1dE;EA4dF;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAIF;EACE;;AAIN;EACE;EACA;EAEA;;AAEF;EACE;;AAEF;EACE;;AAEF;EACE;;AAEF;EACE;EACA;EACA;EACA;;AAGA;EACE;;;AAMR;EACE;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;;;AAGF;EACE,OAriBW;EAsiBX;;;AAGF;EACE;EACA;EACA;EACA;;AACA;EACE;;AAEF;EACE;EACA;EACA;EACA;;;AAIJ;EACE,WA3jBW;EA4jBX;EACA;EACA;EAEA;;;AAEF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE,YAtlBQ;EAulBR;EACA;;;AAGF;EACE;EACA;;AACA;EACE;EACA;EACA;;AAEF;EACE;EACA;EACA;;AACA;EACE;EACA;;;AAKN;EACE;EACA;;AACA;EACE;EACA;;;AAIJ;EACE;IACE;;EAEF;IACE;;EAEF;IACE;IACA;;EAEF;IACE;IACA;IACA;IACA;IACA;;EAEF;IACE;IACA;IACA;;EAEF;IACE;IACA;;EAGA;IACE;IACA;;EAEF;IACE;IACA;IACA;;EAEF;IACE;IACA","file":"styles.css"}
\ No newline at end of file