update guides

Author: jinglescode

apps/docs/content/docs/guides/aiken.mdx

@@ -4,24 +4,23 @@ icon: "guides/aiken.png"
 ---
 import Link from "fumadocs-core/link";
 
-Aiken is a functional programming language created for Cardano smart contract development. It prioritizes on-chain execution and offers a user-friendly approach for building secure and efficient smart contracts, making it a valuable choice for developers aiming to create robust on-chain applications.
+Aiken is a functional programming language for Cardano smart contract development. It prioritizes on-chain execution and offers a user-friendly approach for building secure and efficient smart contracts.
 
-In this tutorial, we will walk you through the process of writing a simple smart contract in Aiken, and create 2 transactions to lock and unlock assets on the Cardano blockchain.
-
-You can also try the <Link href="https://aiken-template.meshjs.dev/">live demo</Link> and here are the codes on the <Link href="https://github.com/MeshJS/aiken-next-ts-template/tree/main">GitHub repository</Link>
+This tutorial walks you through writing a smart contract in Aiken and creating two transactions to lock and unlock assets on the Cardano blockchain.
 
+Try the <Link href="https://aiken-template.meshjs.dev/">live demo</Link>. View the code on the <Link href="https://github.com/MeshJS/aiken-next-ts-template/tree/main">GitHub repository</Link>.
 
 ## System setup
 
-This section will guide you through the process of setting up your system compile Aiken smart contracts. You can skip this section if you have already set up your system or do not wish to compile the contract.
+Set up your system to compile Aiken smart contracts. Skip this section if you have already set up your system or do not wish to compile the contract.
 
-You can also check the installation instructions on the <Link href="https://aiken-lang.org/installation-instructions">Aiken website</Link> for more information.
+Check the installation instructions on the <Link href="https://aiken-lang.org/installation-instructions">Aiken website</Link> for more information.
 
 ### Using aikup (on Linux & MacOS only) [!toc]
 
-If you are using Linux or MacOS, you can use the utility tool to download and manage Aiken's pre-compiled executables.
+Linux and MacOS users can use the utility tool to download and manage Aiken's pre-compiled executables.
 
-You can install the Aiken CLI by running the following command in your terminal:
+Install the Aiken CLI:
 
 ```tsx
 $ curl -sSfL https://install.aiken-lang.org | bash
@@ -30,57 +29,56 @@ $ aikup
 
 ### From sources (all platforms) [!toc]
 
-Aiken is written in Rust, so you will need to install Rust and Cargo to compile the smart contract. You can install Rust by following the instructions on the <Link href="https://www.rust-lang.org/">Rust website</Link>.
+Aiken is written in Rust. Install Rust and Cargo to compile the smart contract. Install Rust via the <Link href="https://www.rust-lang.org/">Rust website</Link>.
 
-Next, you will need Cargo, the Rust package manager. You can install Cargo by following the instructions on the <Link href="https://doc.rust-lang.org/stable/book/ch01-01-installation.html">Cargo website</Link>.
+Install Cargo, the Rust package manager, via the <Link href="https://doc.rust-lang.org/stable/book/ch01-01-installation.html">Cargo website</Link>.
 
-You will know you have successfully installed Rust and Cargo when you can run the following commands in your terminal:
+Verify installation:
 
 ```tsx
 $ rustc --version
 $ cargo --version
 ```
 
-Next, you will need to install the Aiken CLI. You can install the Aiken CLI by running the following command in your terminal:
+Install the Aiken CLI:
 
 ```tsx
 $ cargo install aiken
 ```
 
 ### Check your installation [!toc]
 
-You will know you have successfully installed the Aiken CLI when you can run the following command in your terminal:
+Verify the Aiken CLI installation:
 
 ```tsx
 $ aiken -V
 ```
 
-If you face any issues, please check the installation instructions on the <Link href="https://aiken-lang.org/installation-instructions">Aiken website</Link> for more information.
-
+If issues arise, check the <Link href="https://aiken-lang.org/installation-instructions">Aiken website</Link>.
 
 ## Writing a smart contract with Aiken
 
-In this section, we will walk you through the process of writing a simple smart contract in Aiken. We will also create 2 transactions to lock and unlock assets on the Cardano blockchain.
+Write a smart contract in Aiken and create two transactions to lock and unlock assets.
 
-You can read more about this example on the <Link href="https://aiken-lang.org/example--hello-world/basics">Aiken website</Link>.
+Read more about this example on the <Link href="https://aiken-lang.org/example--hello-world/basics">Aiken website</Link>.
 
 ### Create a new project [!toc]
 
-First, we will create a new project. Please refer to <Link href="/guides/nextjs">this guide</Link> for more information on creating a new Next.js project.
+Create a new project. Refer to <Link href="/guides/nextjs">this guide</Link> for creating a new Next.js project.
 
-Next, we create a new Aiken project within this project folder:
+Create a new Aiken project within this project folder:
 
 ```tsx
 $ aiken meshjs/hello_world
 $ cd hello_world
 $ aiken check
 ```
 
-Remember to check your Aiken project by running `aiken check` after creating a new project and as you develop the contract.
+Run `aiken check` to verify your project.
 
 ### Write the smart contract [!toc]
 
-Let's create file for our validator, `validators/hello_world.ak`:
+Create `validators/hello_world.ak`:
 
 ```tsx
 use aiken/hash.{Blake2b_224, Hash}
@@ -109,32 +107,31 @@ validator {
 }
 ```
 
-This validator checks that the redeemer message is "Hello, World!" and that the transaction is signed by the owner of the datum. If both conditions are met, the validator returns `true`. Otherwise, it returns `false`.
+This validator checks that the redeemer message is "Hello, World!" and that the transaction is signed by the datum owner. Returns `true` if both conditions are met; otherwise `false`.
 
-Let's compile the smart contract with the Aiken CLI:
+Compile the smart contract:
 
 ```tsx
 $ aiken build
 ```
 
-This command will compile the smart contract and generate the `plutus.json` file in the root folder. This file is a <Link href="https://cips.cardano.org/cip/CIP-57">CIP-0057 Plutus blueprint</Link>, blueprint describes your on-chain contract and its binary interface.
-
+This generates `plutus.json` in the root folder. This file is a <Link href="https://cips.cardano.org/cip/CIP-57">CIP-0057 Plutus blueprint</Link>, describing your on-chain contract and its binary interface.
 
 ## Creating locking transaction
 
 ### Preparing the frontend [!toc]
 
-In this section, we will prepare the frontend for our smart contract. We will create a simple UI that allows users to lock and unlock assets on the Cardano blockchain.
+Prepare the frontend to allow users to lock and unlock assets.
 
-Firstly, we need to install the `cbor` package:
+Install `cbor`:
 
 ```tsx
 $ npm install cbor
 ```
 
-Then, we create a folder, `data` and copy the `plutus.json` file into it.
+Create a `data` folder and copy `plutus.json` into it.
 
-Next, open `pages/index.tsx` and import the following packages:
+Open `pages/index.tsx` and import the packages:
 
 ```tsx
 import {
@@ -153,7 +150,7 @@ import cbor from "cbor";
 
 ### Importing the contract [!toc]
 
-We import the contract into our frontend:
+Import the contract:
 
 ```tsx
 const script: PlutusScript = {
@@ -165,13 +162,13 @@ const script: PlutusScript = {
 const scriptAddress = resolvePlutusScriptAddress(script, 0);
 ```
 
-Here, we are using the `plutus.json` file to create the script. We are also using the `resolvePlutusScriptAddress` function to resolve the script address.
+Use `plutus.json` to create the script and `resolvePlutusScriptAddress` to resolve the address.
 
-If you look at it closely, we are encoding with cbor the compiled code of the validator. This is because the validator is encoded in a flat format, which is not the format expected by the cardano-cli and `cardano serialization library`.
+We encode the compiled validator code with cbor because the validator uses a flat format, unlike the format expected by cardano-cli and the serialization library.
 
 ### Locking assets [!toc]
 
-We create the transactions to lock assets on the Cardano blockchain:
+Create the transaction to lock assets:
 
 ```tsx
 const hash = resolvePaymentKeyHash((await wallet.getUsedAddresses())[0]);
@@ -193,16 +190,15 @@ const signedTx = await wallet.signTx(unsignedTx);
 const txHash = await wallet.submitTx(signedTx);
 ```
 
-Here, we are creating a new transaction to lock assets on the Cardano blockchain. We are using the `resolvePaymentKeyHash` function to resolve the payment key hash of the wallet. We are also using the `sendLovelace` function to send lovelace to the script address.
-
-As the contracts requires the owner's address in the datum field, we are creating a new datum with the owner's address. We are then using the `build` function to build the transaction, the `signTx` function to sign the transaction, and the `submitTx` function to submit the transaction to the Cardano blockchain.
+This transaction locks assets. `resolvePaymentKeyHash` resolves the wallet's key hash. `sendLovelace` sends lovelace to the script address.
 
+The contract requires the owner's address in the datum. We build, sign, and submit the transaction.
 
 ## Unlocking assets
 
-Next, we create the transactions to unlock assets.
+Create the transaction to unlock assets.
 
-First, we create a useful function to retrieve the UTXO of the locked assets:
+Retrieve the UTXO of the locked assets:
 
 ```tsx
 async function _getAssetUtxo({ scriptAddress, asset, datum }) {
@@ -218,7 +214,7 @@ async function _getAssetUtxo({ scriptAddress, asset, datum }) {
 }
 ```
 
-And here are the codes to create the transactions to unlock assets:
+Create the unlock transaction:
 
 ```tsx
 const scriptAddress = resolvePlutusScriptAddress(script, 0);
@@ -254,10 +250,10 @@ const signedTx = await wallet.signTx(unsignedTx, true);
 const txHash = await wallet.submitTx(signedTx);
 ```
 
-Here, we are creating a new transaction to unlock assets on the Cardano blockchain. We are using the `resolvePlutusScriptAddress` function to resolve the script address. We are also using the `resolvePaymentKeyHash` function to resolve the payment key hash of the wallet.
+This transaction unlocks assets. `resolvePlutusScriptAddress` resolves the script address. `resolvePaymentKeyHash` resolves the wallet's key hash.
 
-As the contracts requires the owner's address in the datum field, we are creating a new datum with the owner's address. We are then using the `_getAssetUtxo` function to retrieve the UTXO of the locked assets. We are then using the `redeemValue` function to redeem the locked assets, the `sendValue` function to send the assets to the owner's address, and the `setRequiredSigners` function to set the required signers.
+`_getAssetUtxo` retrieves the locked asset UTXO. `redeemValue` redeems the assets. `sendValue` sends assets to the owner. `setRequiredSigners` sets the required signers.
 
-As the validator requires `Hello, World!` as the redeemer message, we are creating a new redeemer with the message `Hello, World!`. We are then using the `build` function to build the transaction, the `signTx` function to sign the transaction, and the `submitTx` function to submit the transaction to the Cardano blockchain.
+The validator requires "Hello, World!" as the redeemer message. We build, sign, and submit the transaction.
 
-You can check the full code on <Link href="https://github.com/MeshJS/aiken-next-ts-template/blob/main/pages/index.tsx">GitHub</Link>.
+Check the full code on <Link href="https://github.com/MeshJS/aiken-next-ts-template/blob/main/pages/index.tsx">GitHub</Link>.