From 9db96d17367680406da9fe598b12912208205729 Mon Sep 17 00:00:00 2001 From: Moudy Date: Wed, 4 Feb 2026 09:20:56 +0100 Subject: [PATCH 1/5] LEZ testnet v0.1 wallet setup tutorial --- LEZ testnet v0.1 tutorials/wallet setup.md | 26 ++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 LEZ testnet v0.1 tutorials/wallet setup.md diff --git a/LEZ testnet v0.1 tutorials/wallet setup.md b/LEZ testnet v0.1 tutorials/wallet setup.md new file mode 100644 index 00000000..e5a43961 --- /dev/null +++ b/LEZ testnet v0.1 tutorials/wallet setup.md @@ -0,0 +1,26 @@ +This repository includes a CLI for interacting with the Logos Blockchain. To install it, run the following command from the root of the repository: + +```bash +cargo install --path wallet --force +``` + +To check that everythin is working, run `wallet help`. + +## Available Wallet Commands + +| Command | Description | +|------------------------|-------------------------------------------------------------| +| `wallet auth-transfer` | Authenticated transfer (init, send) | +| `wallet chain-info` | Chain info queries (current-block-id, block, transaction) | +| `wallet account` | Account management (get, list, new, sync-private) | +| `wallet pinata` | Piñata faucet (claim) | +| `wallet token` | Token operations (new, send) | +| `wallet amm` | AMM operations (new, swap, add-liquidity, remove-liquidity) | +| `wallet check-health` | Health checks that the wallet is connected to the node | +| `wallet config` | Config Setup (get, set) | +| `wallet restore-keys ` | Keys restore from a given password at given `depth` | +| `wallet deploy-program`| Program deployment | +| `wallet help` | Help | + +Some completion scripts exists, see the [completions](./completions/README.md) folder. + From cf374a142255c1ecea284c38f8df7b5b24f18a1f Mon Sep 17 00:00:00 2001 From: Moudy Date: Wed, 4 Feb 2026 11:50:05 +0100 Subject: [PATCH 2/5] token transfer --- LEZ testnet v0.1 tutorials/token transfer.md | 250 +++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 LEZ testnet v0.1 tutorials/token transfer.md diff --git a/LEZ testnet v0.1 tutorials/token transfer.md b/LEZ testnet v0.1 tutorials/token transfer.md new file mode 100644 index 00000000..8019ae56 --- /dev/null +++ b/LEZ testnet v0.1 tutorials/token transfer.md @@ -0,0 +1,250 @@ +This tutorial walks through native token transfers between public and private accounts using the Authenticated-Transfers program. You will create and initialize accounts, fund them with the Pinata program, and run transfers across different privacy combinations. By the end, you will have practiced: +1. Public account creation and initialization. +2. Account funding through the Pinata program. +3. Native token transfers between public accounts. +4. Private account creation. +5. Native token transfer from a public account to a private account. +6. Native token transfer from a public account to a private account owned by someone else. + +--- + +The CLI provides commands to manage accounts. Run `wallet account` to see the options available: +```bash +Commands: + get Get account data + new Produce new public or private account + sync-private Sync private accounts + help Print this message or the help of the given subcommand(s) +``` + +## 1. Public account creation and initialization +> [!Important] +> Public accounts live on-chain and are identified by a 32-byte Account ID. Running `wallet account new public` generates a fresh keypair for the signature scheme used in LEZ. +> The account ID is derived from the public key, and the private key signs transactions and authorizes program executions. +> The CLI can create both public and private accounts. + +### a. New public account creation +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ +``` +> [!Tip] +> Save this account ID. You will use it in later commands. + +### b. Account initialization + +To query the account’s current status, run: + +```bash +# Replace the id with yours +wallet account get --account-id Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ + +# Output: +Account is Uninitialized +``` + +In this example, we initialize the account for the authenticated-transfer program, which manages native token transfers and enforces authenticated debits. + +1. Initialize the account: +```bash +# This command submits a public transaction executing the `init` function of the +# authenticated-transfer program. The wallet polls the sequencer until the +# transaction is included in a block, which may take several seconds. +wallet auth-transfer init --account-id Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ +``` + +2. Check the updated account status: +```bash +wallet account get --account-id Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ + +# Output: +Account owned by authenticated-transfer program +{"balance":0} +``` + +> [!NOTE] +> New accounts start uninitialized, meaning no program owns them yet. Any program may claim an uninitialized account; once claimed, that program owns it. +> Owned accounts can only be modified through executions of the owning program. The only exception is native-token credits: any program may credit native tokens to any account. +> Debiting native tokens must always be performed by the owning program. + +## 2. Account funding through the Piñata program +Now that the account is initialized under the authenticated-tansfer program, fund it using the testnet Piñata program. + +```bash +# Replace with your id +wallet pinata claim --to Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ +``` + +After the claim succeeds, the account is funded: + +```bash +wallet account get --account-id Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ + +# Output: +Account owned by authenticated-transfer program +{"balance":150} +``` + +## 3. Native token transfers between public accounts +LEZ includes a program for managing native tokens. Run `wallet auth-transfer` to see the available commands: +```bash +Commands: + init Initialize account under the authenticated-transfer program + send Send native tokens from one account to another with variable privacy + help Print this message or the help of the given subcommand(s) +``` + +We already used `init`. Now use `send` to execute a transfer. + +### a. Create a recipient account +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/Ev1JprP9BmhbFVQyBcbznU8bAXcwrzwRoPTetXdQPAWS +``` + +> [!NOTE] +> The new account is uninitialized. The authenticated-transfer program will claim any uninitialized account used in a transfer, so manual initialization isn’t required. + +### b. Send 37 tokens to the new account +```bash +wallet auth-transfer send \ + --from Public/9ypzv6GGr3fwsgxY7EZezg5rz6zj52DPCkmf1vVujEiJ \ + --to Public/Ev1JprP9BmhbFVQyBcbznU8bAXcwrzwRoPTetXdQPAWS \ + --amount 37 +``` + +### c. Check both accounts +```bash +# Sender account (use your sender ID) +wallet account get --account-id Public/HrA8TVjBS8UVf9akV7LRhyh6k4c7F6PS7PvqgtPmKAT8 + +# Output: +Account owned by authenticated-transfer program +{"balance":113} +``` + +```bash +# Recipient account +wallet account get --account-id Public/Ev1JprP9BmhbFVQyBcbznU8bAXcwrzwRoPTetXdQPAWS + +# Output: +Account owned by authenticated-transfer program +{"balance":37} +``` + +## 4. Private account creation + +> [!Important] +> Private accounts are structurally identical to public accounts, but their values are stored off-chain. On-chain, only a 32-byte commitment is recorded. +> Transactions include encrypted private values so the owner can recover them, and the decryption keys are never shared. +> Private accounts use two keypairs: nullifier keys for privacy-preserving executions and viewing keys for encrypting and decrypting values. +> The private account ID is derived from the nullifier public key. +> Private accounts can be initialized by anyone, but once initialized they can only be modified by the owner’s keys. +> Updates include a new commitment and a nullifier for the old state, which prevents linkage between versions. + +### a. Create a private account + +```bash +wallet account new private + +# Output: +Generated new account with account_id Private/HacPU3hakLYzWtSqUPw6TUr8fqoMieVWovsUR6sJf7cL +With npk e6366f79d026c8bd64ae6b3d601f0506832ec682ab54897f205fffe64ec0d951 +With ipk 02ddc96d0eb56e00ce14994cfdaec5ae1f76244180a919545983156e3519940a17 +``` + +> [!Tip] +> Focus on the account ID for now. The `npk` and `ipk` values are stored locally and used to build privacy-preserving transactions. The private account ID is derived from `npk`. + +Just like public accounts, new private accounts start out uninitialized: + +```bash +wallet account get --account-id Private/HacPU3hakLYzWtSqUPw6TUr8fqoMieVWovsUR6sJf7cL + +# Output: +Account is Uninitialized +``` + +> [!Important] +> Private accounts are never visible to the network. They exist only in your local wallet storage. + +## 5. Native token transfer from a public account to a private account + +> [!Important] +> Sending tokens to an uninitialized private account causes the authenticated-transfer program to claim it, just like with public accounts. Program logic is the same regardless of account type. + +### a. Send 17 tokens to the private account + +> [!Note] +> The syntax matches public-to-public transfers, but the recipient is a private ID. This runs locally, generates a proof, and submits it to the sequencer. It may take 30 seconds to 4 minutes. + +```bash +wallet auth-transfer send \ + --from Public/Ev1JprP9BmhbFVQyBcbznU8bAXcwrzwRoPTetXdQPAWS \ + --to Private/HacPU3hakLYzWtSqUPw6TUr8fqoMieVWovsUR6sJf7cL \ + --amount 17 +``` + +### b. Check both accounts + +```bash +# Public sender account +wallet account get --account-id Public/Ev1JprP9BmhbFVQyBcbznU8bAXcwrzwRoPTetXdQPAWS + +# Output: +Account owned by authenticated-transfer program +{"balance":20} +``` + +```bash +# Private recipient account +wallet account get --account-id Private/HacPU3hakLYzWtSqUPw6TUr8fqoMieVWovsUR6sJf7cL + +# Output: +Account owned by authenticated-transfer program +{"balance":17} +``` + +> [!Note] +> The last command does not query the network. It works offline because private account data is stored locally. Other users cannot read your private balances. + +> [!Caution] +> Private accounts can only be modified by their owner’s keys. The exception is initialization: any user can initialize an uninitialized private account. This enables transfers to a private account owned by someone else, as long as that account is uninitialized. + +## 6. Native token transfer from a public account to a private account owned by someone else + +> [!Important] +> We’ll simulate transferring to someone else by creating a new private account we own and treating it as if it belonged to another user. + +### a. Create a new uninitialized private account + +```bash +wallet account new private + +# Output: +Generated new account with account_id Private/AukXPRBmrYVqoqEW2HTs7N3hvTn3qdNFDcxDHVr5hMm5 +With npk 0c95ebc4b3830f53da77bb0b80a276a776cdcf6410932acc718dcdb3f788a00e +With ipk 039fd12a3674a880d3e917804129141e4170d419d1f9e28a3dcf979c1f2369cb72 +``` + +> [!Tip] +> Ignore the private account ID here and use the `npk` and `ipk` values to send to a foreign private account. + +```bash +wallet auth-transfer send \ + --from Public/Ev1JprP9BmhbFVQyBcbznU8bAXcwrzwRoPTetXdQPAWS \ + --to-npk 0c95ebc4b3830f53da77bb0b80a276a776cdcf6410932acc718dcdb3f788a00e \ + --to-ipk 039fd12a3674a880d3e917804129141e4170d419d1f9e28a3dcf979c1f2369cb72 \ + --amount 3 +``` + +> [!Warning] +> This command creates a privacy-preserving transaction, which may take a few minutes. The updated values are encrypted and included in the transaction. +> Once accepted, the recipient must run `wallet account sync-private` to scan the chain for their encrypted updates and refresh local state. + +> [!Note] +> You have seen transfers between two public accounts and from a public sender to a private recipient. Transfers from a private sender, whether to a public account or to another private account, follow the same pattern. From e0f1d528b803f54ea7d22b5748c3ae0da3cdbfd4 Mon Sep 17 00:00:00 2001 From: Moudy Date: Wed, 4 Feb 2026 12:10:50 +0100 Subject: [PATCH 3/5] custom tokens --- LEZ testnet v0.1 tutorials/custom tokens.md | 159 ++++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 LEZ testnet v0.1 tutorials/custom tokens.md diff --git a/LEZ testnet v0.1 tutorials/custom tokens.md b/LEZ testnet v0.1 tutorials/custom tokens.md new file mode 100644 index 00000000..ea647696 --- /dev/null +++ b/LEZ testnet v0.1 tutorials/custom tokens.md @@ -0,0 +1,159 @@ +This tutorial focuses on custom tokens using the Token program. As of now, you have used the authenticated-transfers program for native tokens. The Token program is for creating and managing custom tokens. By the end, you will have practiced: +1. Creating new tokens. +2. Transferring custom tokens. + +> [!Important] +> The Token program is a single program that creates and manages all tokens, so you do not deploy a new program for each token. +> Token program accounts fall into two types: +> - Token definition accounts: store token metadata such as name and total supply. This account is the token’s identifier. +> - Token holding accounts: store balances and the definition ID they belong to. + +The CLI provides commands to execute the Token program. Run `wallet token` to see the options: + +```bash +Commands: + new Produce a new token + send Send tokens from one account to another with variable privacy + help Print this message or the help of the given subcommand(s) +``` + +## 1. Creating new tokens + +Use `wallet token new` to execute the `New` function of the Token program. The command expects: +- A token name. +- A total supply. +- Two uninitialized accounts: +- One for the token definition account. +- One for the token holding account that receives the initial supply. + +### a. Public definition account and public supply account + +1. Create two new public accounts: + +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/4X9kAcnCZ1Ukkbm3nywW9xfCNPK8XaMWCk3zfs1sP4J7 +``` + +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw +``` + +2. Create the token (Token A): + +```bash +wallet token new \ + --name TOKENA \ + --total-supply 1337 \ + --definition-account-id Public/4X9kAcnCZ1Ukkbm3nywW9xfCNPK8XaMWCk3zfs1sP4J7 \ + --supply-account-id Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw +``` + +3. Inspect the initialized accounts: + +```bash +wallet account get --account-id Public/4X9kAcnCZ1Ukkbm3nywW9xfCNPK8XaMWCk3zfs1sP4J7 + +# Output: +Definition account owned by token program +{"account_type":"Token definition","name":"TOKENA","total_supply":1337} +``` + +```bash +wallet account get --account-id Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw + +# Output: +Holding account owned by token program +{"account_type":"Token holding","definition_id":"4X9kAcnCZ1Ukkbm3nywW9xfCNPK8XaMWCk3zfs1sP4J7","balance":1337} +``` + +### b. Public definition account and private supply account + +1. Create fresh accounts for this example: + +> [!Important] +> You cannot reuse the accounts from the previous example. Create new ones here. + +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/GQ3C8rbprTtQUCvkuVBRu3v9wvUvjafCMFqoSPvTEVii +``` + +```bash +wallet account new private + +# Output: +Generated new account with account_id Private/HMRHZdPw4pbyPVZHNGrV6K5AA95wACFsHTRST84fr3CF +With npk 6a2dfe433cf28e525aa0196d719be3c16146f7ee358ca39595323f94fde38f93 +With ipk 03d59abf4bee974cc12ddb44641c19f0b5441fef39191f047c988c29a77252a577 +``` + +2. Create the token (Token B): + +```bash +wallet token new \ + --name TOKENB \ + --total-supply 7331 \ + --definition-account-id Public/GQ3C8rbprTtQUCvkuVBRu3v9wvUvjafCMFqoSPvTEVii \ + --supply-account-id Private/HMRHZdPw4pbyPVZHNGrV6K5AA95wACFsHTRST84fr3CF +``` + +3. Inspect the accounts: + +```bash +wallet account get --account-id Public/GQ3C8rbprTtQUCvkuVBRu3v9wvUvjafCMFqoSPvTEVii + +# Output: +Definition account owned by token program +{"account_type":"Token definition","name":"TOKENB","total_supply":7331} +``` + +```bash +wallet account get --account-id Private/HMRHZdPw4pbyPVZHNGrV6K5AA95wACFsHTRST84fr3CF + +# Output: +Holding account owned by token program +{"account_type":"Token holding","definition_id":"GQ3C8rbprTtQUCvkuVBRu3v9wvUvjafCMFqoSPvTEVii","balance":7331} +``` + +> [!Important] +> As a private account, the supply account is visible only in your local wallet storage. + +## 2. Custom token transfers + +The Token program can move balances between token holding accounts. If the recipient account is uninitialized, the token program will automatically claim it. Use `wallet token send` to execute a transfer. + +### a. Create a recipient account + +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 +``` + +### b. Send 1000 TOKENB to the recipient + +```bash +wallet token send \ + --from Private/HMRHZdPw4pbyPVZHNGrV6K5AA95wACFsHTRST84fr3CF \ + --to Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 \ + --amount 1000 +``` + +### c. Inspect the recipient account + +```bash +wallet account get --account-id Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 + +# Output: +Holding account owned by token program +{"account_type":"Token holding","definition_id":"GQ3C8rbprTtQUCvkuVBRu3v9wvUvjafCMFqoSPvTEVii","balance":1000} +``` From 61ffca07e29155fb21111d6a948c4b7159b7ba63 Mon Sep 17 00:00:00 2001 From: Moudy Date: Wed, 4 Feb 2026 12:29:26 +0100 Subject: [PATCH 4/5] amm program --- LEZ testnet v0.1 tutorials/amm.md | 109 ++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 LEZ testnet v0.1 tutorials/amm.md diff --git a/LEZ testnet v0.1 tutorials/amm.md b/LEZ testnet v0.1 tutorials/amm.md new file mode 100644 index 00000000..60751517 --- /dev/null +++ b/LEZ testnet v0.1 tutorials/amm.md @@ -0,0 +1,109 @@ +# Automated Market Maker (AMM) + +This tutorial covers the AMM program in LEZ. The AMM manages liquidity pools and enables swaps between custom tokens. By the end, you will have practiced: +1. Creating a liquidity pool for a token pair. +2. Swapping tokens. +3. Withdrawing liquidity from the pool. +4. Adding liquidity to the pool. + +## 1. Creating a liquidity pool for a token pair + +We start by creating a pool for the tokens created earlier. In return for providing liquidity, you receive liquidity provider (LP) tokens. LP tokens represent your share of the pool and are required to withdraw liquidity later. + +> [!NOTE] +> The AMM does not currently charge swap fees or distribute rewards to liquidity providers. LP tokens therefore represent only a proportional share of the pool reserves. Fee support will be added in future versions. + +### a. Create an LP holding account + +```bash +wallet account new public + +# Output: +Generated new account with account_id Public/FHgLW9jW4HXMV6egLWbwpTqVAGiCHw2vkg71KYSuimVf +``` + +### b. Initialize the pool + +Deposit tokens A and B and specify the account that will receive LP tokens: + +```bash +wallet amm new \ + --user-holding-a Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw \ + --user-holding-b Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 \ + --user-holding-lp Public/FHgLW9jW4HXMV6egLWbwpTqVAGiCHw2vkg71KYSuimVf \ + --balance-a 100 \ + --balance-b 200 +``` + +> [!Important] +> The LP holding account is owned by the token program, so LP tokens are managed using the same token infrastructure as regular tokens. + +```bash +wallet account get --account-id Public/FHgLW9jW4HXMV6egLWbwpTqVAGiCHw2vkg71KYSuimVf + +# Output: +Holding account owned by token program +{"account_type":"Token holding","definition_id":"7BeDS3e28MA5Err7gBswmR1fUKdHXqmUpTefNPu3pJ9i","balance":100} +``` + +> [!Tip] +> If you inspect the `user-holding-a` and `user-holding-b` accounts, you will see that 100 and 200 tokens were deducted. Those tokens now reside in the pool and are available for swaps by any user. + +## 2. Swapping + +Use `wallet amm swap` to perform a token swap: + +```bash +wallet amm swap \ + --user-holding-a Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw \ + --user-holding-b Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 \ + # The amount of tokens to swap + --amount-in 5 \ + # The minimum number of tokens expected in return + --min-amount-out 8 \ + # The definition ID of the token being provided to the swap + # In this case, we are swapping from TOKENA to TOKENB, and so this is the definition ID of TOKENA + --token-definition 4X9kAcnCZ1Ukkbm3nywW9xfCNPK8XaMWCk3zfs1sP4J7 +``` + +Once executed, 5 tokens are deducted from the Token A holding account and the corresponding amount (computed by the pool’s pricing function) is credited to the Token B holding account. + +## 3. Withdrawing liquidity from the pool + +Liquidity providers can withdraw assets by redeeming (burning) LP tokens. The amount received is proportional to the share of LP tokens redeemed relative to the total LP supply. + +Use `wallet amm remove-liquidity`: + +```bash +wallet amm remove-liquidity \ + --user-holding-a Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw \ + --user-holding-b Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 \ + --user-holding-lp Public/FHgLW9jW4HXMV6egLWbwpTqVAGiCHw2vkg71KYSuimVf \ + --balance-lp 20 \ + --min-amount-a 1 \ + --min-amount-b 1 +``` + +> [!Important] +> This burns `balance-lp` LP tokens from the user’s LP holding account. In return, the AMM transfers tokens A and B from the pool vaults to the user’s holding accounts, based on current reserves. +> The `min-amount-a` and `min-amount-b` parameters set the minimum acceptable outputs. If the computed amounts fall below either threshold, the instruction fails to protect against unfavorable pool changes. + +## 4. Adding liquidity to the pool + +To add liquidity, deposit tokens A and B in the ratio implied by current pool reserves. In return, the AMM mints new LP tokens that represent your proportional share. + +Use `wallet amm add-liquidity`: + +```bash +wallet amm add-liquidity \ + --user-holding-a Public/9RRSMm3w99uCD2Jp2Mqqf6dfc8me2tkFRE9HeU2DFftw \ + --user-holding-b Public/88f2zeTgiv9LUthQwPJbrmufb9SiDfmpCs47B7vw6Gd6 \ + --user-holding-lp Public/FHgLW9jW4HXMV6egLWbwpTqVAGiCHw2vkg71KYSuimVf \ + --min-amount-lp 1 \ + --max-amount-a 10 \ + --max-amount-b 10 +``` + +> [!Important] +> `max-amount-a` and `max-amount-b` cap how many tokens A and B can be taken from the user’s accounts. The AMM computes the required amounts based on the pool’s reserve ratio. +> `min-amount-lp` sets the minimum LP tokens to mint. If the computed LP amount falls below this threshold, the instruction fails. From 25b3cd620a2763bc75eeecbea1b1aee0100d3af5 Mon Sep 17 00:00:00 2001 From: Moudy Date: Thu, 5 Feb 2026 15:24:47 +0100 Subject: [PATCH 5/5] changed files names --- LEZ testnet v0.1 tutorials/{custom tokens.md => custom-tokens.md} | 0 .../{token transfer.md => token-transfer.md} | 0 LEZ testnet v0.1 tutorials/{wallet setup.md => wallet-setup.md} | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename LEZ testnet v0.1 tutorials/{custom tokens.md => custom-tokens.md} (100%) rename LEZ testnet v0.1 tutorials/{token transfer.md => token-transfer.md} (100%) rename LEZ testnet v0.1 tutorials/{wallet setup.md => wallet-setup.md} (100%) diff --git a/LEZ testnet v0.1 tutorials/custom tokens.md b/LEZ testnet v0.1 tutorials/custom-tokens.md similarity index 100% rename from LEZ testnet v0.1 tutorials/custom tokens.md rename to LEZ testnet v0.1 tutorials/custom-tokens.md diff --git a/LEZ testnet v0.1 tutorials/token transfer.md b/LEZ testnet v0.1 tutorials/token-transfer.md similarity index 100% rename from LEZ testnet v0.1 tutorials/token transfer.md rename to LEZ testnet v0.1 tutorials/token-transfer.md diff --git a/LEZ testnet v0.1 tutorials/wallet setup.md b/LEZ testnet v0.1 tutorials/wallet-setup.md similarity index 100% rename from LEZ testnet v0.1 tutorials/wallet setup.md rename to LEZ testnet v0.1 tutorials/wallet-setup.md