diff --git a/contract-dev/techniques/zero-knowledge.mdx b/contract-dev/techniques/zero-knowledge.mdx
index 3f5f09323..c11e0ddc0 100644
--- a/contract-dev/techniques/zero-knowledge.mdx
+++ b/contract-dev/techniques/zero-knowledge.mdx
@@ -5,330 +5,397 @@ sidebarTitle: "Zero-knowledge proofs"
 
 import { Aside } from '/snippets/aside.jsx';
 
-This guide shows how to create, compile, and test a simple [Circom](https://docs.circom.io/) scheme and verify a [ZK-proof](https://en.wikipedia.org/wiki/Zero-knowledge_proof) using the [`zk-SNARK`](https://en.wikipedia.org/wiki/Non-interactive_zero-knowledge_proof) [`Groth16`](https://eprint.iacr.org/2016/260.pdf) protocol.
+Create, compile, and test a simple [Circom](https://docs.circom.io/) scheme and verify a [ZK-proof](https://en.wikipedia.org/wiki/Zero-knowledge_proof) using the [zk-SNARK](https://en.wikipedia.org/wiki/Non-interactive_zero-knowledge_proof) [Groth16](https://eprint.iacr.org/2016/260.pdf) protocol.
 
-<Aside>
-  This guide is also applicable to circuits written in the [Noname](https://github.com/zksecurity/noname) language, since the [`export-ton-verifier`](https://github.com/mysteryon88/export-ton-verifier) library integrates with `snarkjs`, which in turn integrates with the Noname language.
+<Aside type="tip">
+  This guide is also applicable to circuits written in the [Noname](https://github.com/zksecurity/noname) language, since the [export-ton-verifier](https://github.com/mysteryon88/export-ton-verifier) library integrates with snarkjs, which in turn integrates with the Noname language.
 
-  Other examples can be found [here](https://github.com/zk-examples/zk-ton-examples/).
+  [The zk-ton-examples repository](https://github.com/zk-examples/zk-ton-examples/) contains additional examples.
 </Aside>
 
 ## Prerequisites
 
 - [Node.js](https://nodejs.org) 18 or a later LTS.
-- [`circom`](https://docs.circom.io/getting-started/installation/#installing-circom)
-- [`snarkjs`](https://docs.circom.io/getting-started/installation/#installing-snarkjs)
+- [Circom](https://docs.circom.io/getting-started/installation/#installing-circom)
+- [snarkjs](https://docs.circom.io/getting-started/installation/#installing-snarkjs)
 - [Blueprint](/contract-dev/blueprint/overview)
 
-## Project setup
-
-1. Create a new project using Blueprint:
-
-   ```bash
-   npm create ton@latest ZkSimple
-   cd ZkSimple
-   ```
-1. Install libraries for working with ZK-proofs:
-
-   ```bash
-   npm install snarkjs @types/snarkjs
-   ```
-1. Install the verifier export utility for TON:
-
-   ```bash
-   npm install export-ton-verifier@latest
-   ```
-
-This utility exports verifier contracts for FunC, Tolk, and Tact.
+## Initialize a project
+
+<Steps>
+  <Step
+    title="Create a new project"
+  >
+    ```bash
+    npm create ton@latest ZkSimple && cd ZkSimple
+    ```
+  </Step>
+
+  <Step
+    title="Install dependencies"
+  >
+    ```bash
+    npm install snarkjs @types/snarkjs export-ton-verifier@latest
+    ```
+  </Step>
+</Steps>
 
 ## Create the Circom circuit
 
-Create the directory `circuits/Multiplier` and the file `Multiplier.circom`:
-
-```bash
-mkdir -p circuits/Multiplier
-cd circuits/Multiplier
-```
-
-```circom
-pragma circom 2.2.2;
-
-template Multiplier() {
-  signal input a;
-  signal input b;
-
-  signal output c;
-
-  c <== a*b;
-}
-
-component main = Multiplier();
-```
-
-This circuit proves knowledge of two numbers `a` and `b`, whose product is equal to the public output `c`, without revealing `a` and `b` themselves.
-
-### Compile
-
-Run in `circuits/Multiplier`:
-
-```bash
-circom Multiplier.circom --r1cs --wasm --sym --prime bls12381
-```
-
-After compilation, the following files will appear:
-
-- `Multiplier.r1cs` — circuit constraints (R1CS)
-- `Multiplier.sym` — symbolic signal map
-- `Multiplier.wasm` — artifact for generating proof
-
-Check constraints:
-
-```bash
-snarkjs r1cs info Multiplier.r1cs
-```
-
-Output example:
-
-```
-[INFO]  snarkJS: Curve: bls12-381
-[INFO]  snarkJS: # of Wires: 4
-[INFO]  snarkJS: # of Constraints: 1
-[INFO]  snarkJS: # of Private Inputs: 2
-[INFO]  snarkJS: # of Public Inputs: 0
-[INFO]  snarkJS: # of Outputs: 1
-```
-
-<Aside>
-  `snarkjs` supports the [`alt_bn128`](https://eips.ethereum.org/EIPS/eip-196) and [`bls12-381`](https://electriccoin.co/blog/new-snark-curve/) curves. Ethereum uses `alt_bn128`, but `bls12-381` is used for TON, so it is the one chosen in this guide.
-</Aside>
-
-## Trusted setup (`Groth16`)
-
-The **trusted setup** is a one-time ceremony that generates the proving and verification keys for a circuit. It's called "trusted" because if the setup parameters are compromised, proofs could be forged. For production use, participate in a multi-party trusted setup ceremony. For local development and testing, a simplified single-party setup is sufficient. For local tests, perform a simplified trusted setup ceremony.
-
-The "power of tau" parameter (`10`) has to be chosen
-
-- as low as possible, because it affects execution time;
-- high enough, because the more constraints in the scheme, the higher the parameter required.
-
-```bash
-# first phase
-snarkjs powersoftau new bls12-381 10 pot10_0000.ptau -v
-snarkjs powersoftau contribute pot10_0000.ptau pot10_0001.ptau --name="First contribution" -v -e="some random text"
-
-# second phase (depends on the compiled scheme)
-snarkjs powersoftau prepare phase2 pot10_0001.ptau pot10_final.ptau -v
-snarkjs groth16 setup Multiplier.r1cs pot10_final.ptau Multiplier_0000.zkey
-snarkjs zkey contribute Multiplier_0000.zkey Multiplier_final.zkey --name="1st Contributor" -v -e="some random text"
-
-# export verification key
-snarkjs zkey export verificationkey Multiplier_final.zkey verification_key.json
-```
-
-Clear up unnecessary artifacts:
-
-```sh
-rm pot10_0000.ptau pot10_0001.ptau pot10_final.ptau Multiplier_0000.zkey
-```
+<Steps>
+  <Step
+    title="Create the circuit directory"
+  >
+    ```bash
+    mkdir -p circuits/Multiplier && cd circuits/Multiplier
+    ```
+
+    Run the commands from the following steps in the `circuits/Multiplier` directory, or adjust the paths accordingly if running from the project root.
+  </Step>
+
+  <Step
+    title="Implement the circuit"
+  >
+    This circuit proves knowledge of two numbers `a` and `b`, whose product is equal to the public output `c`, without revealing `a` and `b` themselves.
+
+    ```circom title="./circuits/Multiplier/Multiplier.circom"
+    pragma circom 2.2.2;
+
+    template Multiplier() {
+      signal input a;
+      signal input b;
+
+      signal output c;
+
+      c <== a*b;
+    }
+
+    component main = Multiplier();
+    ```
+  </Step>
+
+  <Step
+    title="Compile the circuit"
+  >
+    ```bash
+    circom Multiplier.circom --r1cs --wasm --sym --prime bls12381
+    ```
+
+    The compiler generates the following files:
+
+    - `Multiplier.r1cs` — circuit constraints (R1CS)
+    - `Multiplier.sym` — symbolic signal map
+    - `Multiplier_js/Multiplier.wasm` — artifact for generating proof
+  </Step>
+
+  <Step
+    title="Check the constraints"
+  >
+    ```bash
+    snarkjs r1cs info Multiplier.r1cs
+    ```
+
+    ```text title="snarkjs output"
+    [INFO]  snarkJS: Curve: bls12-381
+    [INFO]  snarkJS: # of Wires: 4
+    [INFO]  snarkJS: # of Constraints: 1
+    [INFO]  snarkJS: # of Private Inputs: 2
+    [INFO]  snarkJS: # of Public Inputs: 0
+    [INFO]  snarkJS: # of Labels: 4
+    [INFO]  snarkJS: # of Outputs: 1
+    ```
+
+    <Aside
+      type="note"
+    >
+      snarkjs supports the [alt\_bn128](https://eips.ethereum.org/EIPS/eip-196) and [bls12-381](https://electriccoin.co/blog/new-snark-curve/) curves. This guide uses bls12-381 because it is supported by TON.
+    </Aside>
+  </Step>
+</Steps>
+
+## Initialize trusted setup
+
+The trusted setup is a one-time ceremony that generates the proving and verification keys for a circuit. It is called trusted because if the setup parameters are compromised, proofs could be forged.
+
+- For production use, participate in a multi-party trusted setup ceremony.
+- For local development and testing, a simplified single-party setup is sufficient.
+
+Choose the "power of tau" parameter (`10`) as low as possible, because it affects execution time, but not too low, because the more constraints in the scheme, the higher the parameter required.
+
+<Steps>
+  <Step
+    title="Execute the first phase"
+  >
+    ```bash
+      snarkjs powersoftau new bls12-381 10 pot10_0000.ptau -v
+      snarkjs powersoftau contribute pot10_0000.ptau pot10_0001.ptau --name="First contribution" -v -e="some random text"
+    ```
+  </Step>
+
+  <Step
+    title="Execute the second phase"
+  >
+    ```bash
+      snarkjs powersoftau prepare phase2 pot10_0001.ptau pot10_final.ptau -v
+      snarkjs groth16 setup Multiplier.r1cs pot10_final.ptau Multiplier_0000.zkey
+      snarkjs zkey contribute Multiplier_0000.zkey Multiplier_final.zkey --name="1st Contributor" -v -e="some random text"
+    ```
+  </Step>
+
+  <Step
+    title="Export the verification key"
+  >
+    ```bash
+    snarkjs zkey export verificationkey Multiplier_final.zkey verification_key.json
+    ```
+  </Step>
+
+  <Step
+    title="Clean up artifacts"
+  >
+    ```bash
+    rm pot10_0000.ptau pot10_0001.ptau pot10_final.ptau Multiplier_0000.zkey
+    ```
+
+    Run the commands from the following steps in the project root.
+  </Step>
+</Steps>
 
 ## Export the verifier contract
 
-Return to the Blueprint project root before running these commands if you are still in `circuits/Multiplier`:
-
-```bash
-cd ../..
-```
-
-```bash
-# export Tolk contract (default for Groth16)
-npx export-ton-verifier ./circuits/Multiplier/Multiplier_final.zkey ./contracts/verifier_multiplier.tolk
-
-# export FunC contract
-npx export-ton-verifier ./circuits/Multiplier/Multiplier_final.zkey ./contracts/verifier_multiplier.fc --func
-
-# export Tact contract
-npx export-ton-verifier ./circuits/Multiplier/Multiplier_final.zkey ./contracts/verifier_multiplier.tact --tact
-```
-
-For FunC and Tolk, generate the wrapper that matches your contract target in `./wrappers/`:
-
-```bash
-# Copy the TypeScript wrapper for Tolk
-npx export-ton-verifier import-wrapper ./wrappers/Verifier_tolk.ts --groth16 --force
-
-# Copy the TypeScript wrapper for FunC
-npx export-ton-verifier import-wrapper ./wrappers/Verifier_func.ts --groth16 --func --force
-```
-
-These commands copy TypeScript wrapper files that provide type-safe methods for interacting with the verifier contract. If you keep both wrappers in the same project, update the test import to match the wrapper you generated: use `Verifier_tolk` for Tolk and `Verifier_func` for FunC.
-
-## Testing and verification
-
-In `tests/ZkSimple.spec.ts`:
+<Steps>
+  <Step
+    title="Export the verifier contract"
+  >
+    ```bash
+    npx export-ton-verifier ./circuits/Multiplier/Multiplier_final.zkey ./contracts/verifier_multiplier.tolk
+    ```
+  </Step>
 
-```ts
-import * as snarkjs from 'snarkjs';
-import path from 'path';
-import { dictFromInputList, groth16CompressProof } from 'export-ton-verifier';
+  <Step
+    title="Generate TypeScript wrappers"
+  >
+    These TypeScript wrappers enable type-safe interaction with the verifier contract.
 
-// for Tact (After running `npx blueprint build --all`)
-import { Verifier } from '../build/Verifier_tact/tact_Verifier';
+    ```bash
+    npx export-ton-verifier import-wrapper ./wrappers/Verifier_tolk.ts --groth16 --force
+    ```
+  </Step>
+</Steps>
 
-// for Tolk
-import { Verifier } from '../wrappers/Verifier_tolk';
-
-// for FunC
-import { Verifier } from '../wrappers/Verifier_func';
-```
-
-Local verification:
-
-```ts
-const wasmPath = path.join(__dirname, '../circuits/Multiplier', 'Multiplier.wasm');
-const zkeyPath = path.join(__dirname, '../circuits/Multiplier', 'Multiplier_final.zkey');
-const verificationKey = require('../circuits/Multiplier/verification_key.json');
-
-const input = { a: '342', b: '1245' };
-
-const { proof, publicSignals } = await snarkjs.groth16.fullProve(input, wasmPath, zkeyPath);
-const okLocal = await snarkjs.groth16.verify(verificationKey, publicSignals, proof);
-```
-
-On-chain verification:
-
-```ts
-const { pi_a, pi_b, pi_c, pubInputs } = await groth16CompressProof(proof, publicSignals);
-
-// Quick check via get-method: verifies the proof locally without changing blockchain state.
-expect(await verifier.getVerify({ pi_a, pi_b, pi_c, pubInputs })).toBe(true);
-
-// Send the proof to the contract in a message
-// The contract will run verification; handling the result/flow is up to the developer using this template.
-await verifier.sendVerify(deployer.getSender(), { pi_a, pi_b, pi_c, pubInputs, value: toNano('0.15') });
-```
+## Test and verify the proof
 
 <Aside type="tip">
-  Build the contracts before running tests. For Tact contracts, run `npx blueprint build --all` first. For FunC/Tolk, ensure the wrappers are generated.
+  Build the contracts and generate the TypeScript wrappers before running tests.
 </Aside>
 
-## Other Languages
-
-This tutorial follows the path **Circom → `snarkjs` → `export-ton-verifier` → TON**.
-The same workflow applies to other stacks — the key requirement is to obtain a `proof` and a `verification key` in `snarkjs` format.
-
-In the example repository — [`zk-ton-examples`](https://github.com/zk-examples/zk-ton-examples/) — there are already templates for `noname`, `gnark`, and `arkworks`: proofs can be generated in any of these stacks, then converted into `snarkjs` format and verified both locally and on-chain in the same way.
+<Steps>
+  <Step
+    title="Import dependencies"
+  >
+    ```ts title="./tests/ZkSimple.spec.ts"
+    import * as snarkjs from 'snarkjs';
+    import path from 'path';
+    import { dictFromInputList, groth16CompressProof } from 'export-ton-verifier';
+    import { Verifier } from '../wrappers/Verifier_tolk';
+    ```
+  </Step>
+
+  <Step
+    title="Implement local verification"
+  >
+    ```ts title="./tests/ZkSimple.spec.ts"
+    it("should verify the proof locally", async () => {
+      const wasmPath = path.join(
+        __dirname,
+        '../circuits/Multiplier/Multiplier_js',
+        'Multiplier.wasm'
+      );
+      const zkeyPath = path.join(
+        __dirname,
+        '../circuits/Multiplier',
+        'Multiplier_final.zkey'
+      );
+      const verificationKey = require('../circuits/Multiplier/verification_key.json');
+
+      const input = { a: '342', b: '1245' };
+
+      const {
+        proof,
+        publicSignals
+      } = await snarkjs.groth16.fullProve(input, wasmPath, zkeyPath);
+
+      const okLocal = await snarkjs.groth16.verify(verificationKey, publicSignals, proof);
+      expect(okLocal).toBe(true);
+    });
+    ```
+  </Step>
+
+  <Step
+    title="Implement on-chain verification"
+  >
+    ```ts title="./tests/ZkSimple.spec.ts"
+    it("should verify the proof on-chain", async () => {
+      const { pi_a, pi_b, pi_c, pubInputs } = await groth16CompressProof(proof, publicSignals);
+
+      // Quick check via get-method: verifies the proof locally without changing blockchain state.
+      expect(await verifier.getVerify({ pi_a, pi_b, pi_c, pubInputs })).toBe(true);
+
+      // Send the proof to the contract in a message.
+      // The contract will run verification; subsequent handling of the result depends on the integration.
+      await verifier.sendVerify
+        deployer.getSender(),
+        { pi_a, pi_b, pi_c, pubInputs, value: toNano('0.15') }
+      );
+    });
+    ```
+  </Step>
+</Steps>
+
+## Other languages
+
+This tutorial follows the path: Circom → snarkjs → export-ton-verifier → TON.
+
+The same workflow applies to other stacks, the key requirement is to obtain a proof and a verification key in the snarkjs format. The idea is always the same: generate `proof.json` and `verification_key.json` in the snarkjs format, then perform the verification in TON with the export-ton-verifier.
+
+[The zk-ton-examples repository](https://github.com/zk-examples/zk-ton-examples/) contains templates for Noname, gnark, and Arkworks. It is possible to generate proofs in any of these stacks, then convert them to the snarkjs format and verify them both locally and on-chain.
 
-<Aside>
-  Two utilities are available that help convert proofs and verification keys into a format compatible with `snarkjs`:
-
-  - [`ark-snarkjs`](https://github.com/mysteryon88/ark-snarkjs): use for exporting from `arkworks`
-  - [`gnark-to-snarkjs`](https://github.com/mysteryon88/gnark-to-snarkjs): use for exporting from `gnark`
-</Aside>
-
-The idea is always the same: generate `proof.json` and `verification_key.json` in `snarkjs` format, then use `export-ton-verifier` and perform verification in TON.
-
-### Arkworks (Rust)
-
-Use the `arkworks` library to generate the proof and verification key, then convert them into `snarkjs` format with `ark-snarkjs`.
-
-1. Set up an Arkworks project:
-
-```sh
-cargo init
-cargo add ark-bls12-381 ark-ff ark-groth16 ark-r1cs-std ark-relations ark-snark ark-snarkjs ark-std rand@0.8.5
-```
-
-<Aside>
-  The packages listed above are the core dependencies needed for most `arkworks` circuits. Depending on the specific circuit implementation, additional packages may be required.
+<Aside type="tip">
+  Two utilities are available that help convert proofs and verification keys in a format compatible with snarkjs: [ark-snarkjs](https://github.com/mysteryon88/ark-snarkjs) and [gnark-to-snarkjs](https://github.com/mysteryon88/gnark-to-snarkjs).
 </Aside>
 
-2. Write the circuit in Rust. Implement the circuit logic using `arkworks` primitives, similar to how a Circom circuit would be written. Learn how to write constraints in `arkworks` by following the [Arkworks R1CS tutorial](https://github.com/arkworks-rs/r1cs-tutorial). A working example of a simple multiplication circuit can be found in the [`zk-ton-examples` repository](https://github.com/zk-examples/zk-ton-examples/tree/main/circuits/Arkworks/MulCircuit).
-
-2. Compile, generate proof, and perform trusted setup following the same workflow as in the Circom section above.
-
-2. Export the proof and verification key to JSON using `ark-snarkjs`:
-
-```rust
-use ark_snarkjs::{export_proof, export_vk};
-use ark_bls12_381::{Bls12_381, Fr};
-
-let _ = export_proof::<Bls12_381, _>(&proof, &public_inputs, "json/proof.json");
-let _ = export_vk::<Bls12_381, _>(
-    &params.vk,
-    public_inputs.len(),
-    "json/verification_key.json",
-);
-```
-
-The directory and files will be created automatically.
-
-5. Export the verifier contract:
-
-```sh
-# Tolk contract (default)
-npx export-ton-verifier ./circuits/Arkworks/MulCircuit/json/verification_key.json ./contracts/verifier_ark.tolk
-
-# FunC contract
-npx export-ton-verifier ./circuits/Arkworks/MulCircuit/json/verification_key.json ./contracts/verifier_ark.fc --func
-
-# Tact contract
-npx export-ton-verifier ./circuits/Arkworks/MulCircuit/json/verification_key.json ./contracts/verifier_ark.tact --tact
-```
-
-### `gnark` (Go)
-
-Use the `gnark` library to generate the proof and verification key, then convert them into `snarkjs` format with `gnark-to-snarkjs`.
-
-1. Set up a `gnark` project. You can find an example circuit in the [`gnark` repository](https://github.com/Consensys/gnark?tab=readme-ov-file#example). A working example of a cubic circuit can be found in the [`zk-ton-examples` repository](https://github.com/zk-examples/zk-ton-examples/tree/main/circuits/Cubic%20%28gnark%29).
-
-1. Add `gnark-to-snarkjs` as a dependency:
-
-```sh
-go get github.com/mysteryon88/gnark-to-snarkjs@latest
-```
-
-3. Export the proof and verification key:
-
-```go
-{
-  proof_out, _ := os.Create("proof.json")
-  defer proof_out.Close()
-  _ = gnarktosnarkjs.ExportProof(proof, []string{"35"}, proof_out)
-}
-{
-  out, _ := os.Create("verification_key.json")
-  defer out.Close()
-  _ = gnarktosnarkjs.ExportVerifyingKey(vk, out)
-}
-```
-
-4. Export the verifier contract:
-
-```sh
-# Tolk contract (default)
-npx export-ton-verifier ./circuits/cubic-gnark/verification_key.json ./contracts/verifier_cubic.tolk
-
-# FunC contract
-npx export-ton-verifier ./circuits/cubic-gnark/verification_key.json ./contracts/verifier_cubic.fc --func
-
-# Tact contract
-npx export-ton-verifier ./circuits/cubic-gnark/verification_key.json ./contracts/verifier_cubic.tact --tact
-```
-
-## Conclusion
-
-This guide demonstrates a minimal example: **circuit → trusted setup → verifier export → verification in TON**. This workflow can be extended to support more complex circuits and real-world applications.
+### Rust
+
+Use the Arkworks library to generate the proof and verification key, then convert them into snarkjs format with ark-snarkjs.
+
+<Steps>
+  <Step
+    title="Create a new project"
+  >
+    ```bash
+    cargo init
+    cargo add ark-bls12-381 ark-ff ark-groth16 ark-r1cs-std ark-relations ark-snark ark-snarkjs ark-std rand@0.8.5
+    ```
+
+    <Aside
+      type="note"
+    >
+      The listed packages are core dependencies for most Arkworks circuits. Depending on the specific circuit implementation, additional packages may be required.
+    </Aside>
+  </Step>
+
+  <Step
+    title="Implement the circuit"
+  >
+    Implement the circuit logic using Arkworks primitives, similar to a Circom circuit.
+
+    <Aside
+      type="tip"
+    >
+      Learn how to write constraints in Arkworks by following the [Arkworks R1CS tutorial](https://github.com/arkworks-rs/r1cs-tutorial).
+
+      [The zk-ton-examples repository](https://github.com/zk-examples/zk-ton-examples/tree/main/circuits/Arkworks/MulCircuit) contains a working example of a simple multiplication circuit.
+    </Aside>
+  </Step>
+
+  <Step
+    title="Compile, generate proof, perform trusted setup"
+  >
+    Follow the same workflow as in [the Circom section](#create-the-circom-circuit) and [the trusted setup section](#initialize-trusted-setup), but implement the logic in Rust with Arkworks instead of Circom. The resulting proof and verification key will be in Arkworks format, which can be converted to snarkjs format with ark-snarkjs.
+  </Step>
+
+  <Step
+    title="Export the proof and verification key"
+  >
+    The following script will create the directory and files automatically.
+
+    ```rust title="Rust"
+    use ark_snarkjs::{export_proof, export_vk};
+    use ark_bls12_381::Bls12_381;
+
+    let _ = export_proof::<Bls12_381, _>(&proof, &public_inputs, "json/proof.json");
+    let _ = export_vk::<Bls12_381, _>(
+        &params.vk,
+        public_inputs.len(),
+        "json/verification_key.json",
+    );
+    ```
+  </Step>
+
+  <Step
+    title="Export the verifier contract"
+  >
+    ```bash
+    npx export-ton-verifier ./circuits/Arkworks/MulCircuit/json/verification_key.json ./contracts/verifier_ark.tolk
+    ```
+  </Step>
+</Steps>
+
+### Go
+
+Use the gnark library to generate the proof and verification key, then convert them to the snarkjs format with gnark-to-snarkjs.
+
+<Steps>
+  <Step
+    title="Create a new project"
+  >
+    ```bash
+    mkdir zk-ton-gnark && cd zk-ton-gnark
+    go mod init zk-ton-gnark
+
+    ```
+
+    <Aside
+      type="tip"
+    >
+      [The gnark repository](https://github.com/Consensys/gnark) contains an example circuit.
+
+      [The zk-ton-examples repository](https://github.com/zk-examples/zk-ton-examples/tree/main/circuits/Cubic%20%28gnark%29) contains a working example of a simple cubic circuit.
+    </Aside>
+  </Step>
+
+  <Step
+    title="Install the dependencies"
+  >
+    ```bash
+    go get github.com/consensys/gnark@latest
+    go get github.com/mysteryon88/gnark-to-snarkjs@latest
+    ```
+  </Step>
+
+  <Step
+    title="Export the proof and verification key"
+  >
+    ```go title="Go"
+    {
+      proof_out, _ := os.Create("proof.json")
+      defer proof_out.Close()
+      _ = gnarktosnarkjs.ExportProof(proof, []string{"35"}, proof_out)
+    }
+    {
+      out, _ := os.Create("verification_key.json")
+      defer out.Close()
+      _ = gnarktosnarkjs.ExportVerifyingKey(vk, out)
+    }
+    ```
+  </Step>
+
+  <Step
+    title="Export the verifier contract"
+  >
+    ```bash
+    npx export-ton-verifier ./circuits/cubic-gnark/verification_key.json ./contracts/verifier_cubic.tolk
+    ```
+  </Step>
+</Steps>
 
 ## Useful Links
 
-- Example repository: [`zk-ton-examples`](https://github.com/zk-examples/zk-ton-examples/)
-- Verifier export library: [`export-ton-verifier`](https://github.com/mysteryon88/export-ton-verifier)
-- Additional utilities:
-  - [`ark-snarkjs`](https://github.com/mysteryon88/ark-snarkjs)
-  - [`gnark-to-snarkjs`](https://github.com/mysteryon88/gnark-to-snarkjs)
-- Using ZK-proofs in Tact: [docs.tact](https://docs.tact-lang.org/cookbook/zk-proofs/)
-- Circom: [docs.circom.io](https://docs.circom.io/)
-- Noname: [`zksecurity/noname`](https://github.com/zksecurity/noname)
-- `gnark`: [`consensys/gnark`](https://github.com/Consensys/gnark)
-- Arkworks: [`arkworks`](https://arkworks.rs/)
-- SnarkJS: [`iden3/snarkjs`](https://github.com/iden3/snarkjs)
+- [The zk-ton-examples repository](https://github.com/zk-examples/zk-ton-examples/) contains additional examples of zk-SNARK circuits and their integration with TON.
+- [The export-ton-verifier repository](https://github.com/mysteryon88/export-ton-verifier) is a library that generates TON-compatible verifier contracts from snarkjs verification keys.
+- [The snarkjs repository](https://github.com/iden3/snarkjs) is a JavaScript library for generating and verifying zk-SNARK proofs, as well as performing trusted setup ceremonies.
+- [The ark-snarkjs repository](https://github.com/mysteryon88/ark-snarkjs) is a utility that converts Arkworks proofs and verification keys into a format compatible with snarkjs.
+- [The gnark-to-snarkjs repository](https://github.com/mysteryon88/gnark-to-snarkjs) is a utility that converts gnark proofs and verification keys into a format compatible with snarkjs.
+- [The Noname repository](https://github.com/zksecurity/noname) is a high-level language for writing zk-SNARK circuits, which can be compiled to a format compatible with snarkjs.
+- [The gnark repository](https://github.com/Consensys/gnark) is a Go library for writing zk-SNARK circuits and generating proofs.
+- [The Arkworks homepage](https://arkworks.rs/) is a Rust ecosystem for zk-SNARKs, providing libraries for writing circuits, generating proofs, and performing trusted setup ceremonies.
diff --git a/resources/dictionaries/custom.txt b/resources/dictionaries/custom.txt
index a2bc93031..2d557f2e3 100644
--- a/resources/dictionaries/custom.txt
+++ b/resources/dictionaries/custom.txt
@@ -91,6 +91,7 @@ blockquote
 blockquotes
 Blockscout
 BLS
+bls
 bmTON
 BoC
 BoCs
@@ -299,10 +300,12 @@ Gilmanova
 gitbook
 Gitpod
 globals
+gnark
 Goldschlag
 Golev
 Grafana
 grammY
+Groth
 GTon
 Gunicorn
 gusarich
@@ -658,6 +661,7 @@ Singlechain
 skillset
 skywardboundd
 smartcont
+snarkjs
 Solana
 Soulbound
 Spellbook
@@ -844,6 +848,7 @@ Zakrevskis
 Zellic
 zerostate
 ZK-proof
+zk-SNARK
 Gbit
 Mbit
 tonstatus
diff --git a/resources/dictionaries/two-letter-words-ban.txt b/resources/dictionaries/two-letter-words-ban.txt
index b7f8a269b..423754383 100644
--- a/resources/dictionaries/two-letter-words-ban.txt
+++ b/resources/dictionaries/two-letter-words-ban.txt
@@ -2417,7 +2417,6 @@
 !Zj
 !ZJ
 !zJ
-!zk
 !Zk
 !ZK
 !zK