### Step 4: Get your API key
Click on the `Generate new key` button to generate a new API key.
> **Warning**
>
> **IMPORTANT**
>
> 1. Every API key will only be shown once on the dashboard, so make sure to copy and save it securely.
> 2. You can always delete an existing API key, or generate a new one.
### Step 5: Use the API key to submit data
Once you have your API key, feel free to head on over to our
[API reference](/docs/da/api-reference/avail-turbo-da-api) to start leveraging the power of Turbo DA.
### Node Types
## Introduction
While Avail diverges from conventional blockchain frameworks to concentrate on modular solutions tailored for data availability, it continues to utilize a diverse array of node types. These nodes differ in their functions, storage needs, and levels of engagement within the network.
## Node Types Comparison
**Note:** Infrastructure providers can host all types of Avail nodes.
| Node Type | Storage Requirement | Network Role | Special Features | Use Case | Typically Hosted By |
| --------------- | ------------------- | ------------ | ---------------- | ---------------------------------------- | ------------------------------------------------------------- |
| Light Clients | Low | Interaction | Minimal Storage | Quick Queries, Low-resource Environments | End users in low-resource environments |
| Full Nodes | Moderate | Core | Network Access | Transaction Verification, Data Retrieval | Regular network participants, those involved in verification |
| Validator Nodes | Moderate | Core | Block Production | Network Security, Governance | Trusted entities, elected participants, staked node providers |
| RPC Nodes | Moderate | Gateway | API Exposure | Development, Remote Access | Developers, entities requiring remote network access |
## Overview of Node Types
### Light Clients
Light clients allow users to interact with the blockchain without downloading the entire transaction history. They rely on a trusted set of nodes for the data needed to engage with the network.
### Full Nodes
Full nodes maintain the blockchain's current state but do not store its entire history. Optimized for quick access to current data, they are ideal for tasks like transaction verification.
### Validator Nodes
Validator nodes are specialized full nodes that participate in block production and network governance. They are staked to ensure network security and integrity.
### RPC Nodes
RPC nodes expose an API for remote interactions, serving as a gateway for developers and external clients to engage with the Avail network.
## Next Steps
Now that you have a comprehensive understanding of the various node types within the Avail network, it's recommended to take your first step by setting up a Light Client. Before you begin, make sure to review the [System Requirements guide](/docs/da/operate/run-a-full-node/overview). Once you're ready, you can proceed to the [Light Client Deployment guide](/docs/da/operate/run-a-light-client/light-client) to get started.
> Light Clients provide an accessible entry point to the Avail network, enabling quick interactions without storing the full blockchain. Ideal for newcomers, they play an integral role in maintaining a robust data availability layer.
### Full Node
Run a full Avail node for complete block storage and network participation. Read the overview for requirements, then follow the setup guide.
- [**Overview**](/docs/da/operate/run-a-full-node/overview) — Architecture, hardware requirements, and what a full node does on the network.
- [**Run an Avail Node**](/docs/da/operate/run-a-full-node/full-node) — Step-by-step guide to install and run a full Avail node.
### Deployment Options
Different service providers offer hosted deployment options for Avail. These platforms simplify the management of blockchain infrastructure by providing cloud-based services and comprehensive support for network deployment and maintenance.
| Service | Description | Deployment Type | Documentation |
| ------- | --------------------------------------------------------------------------------------------------------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| Spheron | Cloud-based, decentralized, infrastructure services for blockchain applications, offering simplicity and scalability. | Hosted | [Deploy and Operate an Avail Testnet Validator](https://blog.spheron.network/deploy-an-avail-node-in-minutes-using-spheron-compute) |
### Become a Validator
Become an Avail DA validator. These guides walk you through the full lifecycle — follow them in order from Basics through Monitoring.
- [**Basics**](/docs/da/operate/become-a-validator/basics) — Requirements, economics, and what it means to validate on Avail DA.
- [**Simple Deployment**](/docs/da/operate/become-a-validator/deployment) — Deploy your validator node with a straightforward setup.
- [**Session Keys**](/docs/da/operate/become-a-validator/session-keys) — Generate and set session keys for block production.
- [**Stake Your Validator**](/docs/da/operate/become-a-validator/stake-your-validator) — Bond AVAIL tokens and register your validator on-chain.
- [**Backup Your Validator**](/docs/da/operate/become-a-validator/backup-your-validator) — Back up keys and state to protect against data loss.
- [**Upgrade Your Validator**](/docs/da/operate/become-a-validator/upgrade-your-validator) — Upgrade your node software without downtime.
- [**Monitor Your Validator**](/docs/da/operate/become-a-validator/monitor-your-validator) — Track performance, uptime, and on-chain status.
- [**Chill Your Validator**](/docs/da/operate/become-a-validator/chill-your-validator) — Temporarily take your validator offline without unbonding.
### Accounts
## Introduction
This guide will walk you through two different ways of creating an account on Avail, while also providing insights into the account specifications and formats.
### Seed Phrases
Before creating an account, it's essential to understand [seed phrases](https://en.wikipedia.org/wiki/Cryptocurrency_wallet). During the account creation process, you'll receive a seed phrase—a series of words that can be used to recover your account.
> **Error**
>
> SEED PHRASE SECURITY
>
> NEVER EVER share your seed phrase with anyone and keep it in a secure location. Anyone with access to your seed phrase can gain control of your account.
## Creating an Account on Avail DA
In this guide, we will walk you through two different ways of creating an account on Avail DA.
1. **Using a compatible wallet**: You can create an account by using wallets like
[SubWallet](https://www.subwallet.app/), [Talisman](https://www.talisman.xyz/), [PolkadotJS](https://polkadot.js.org/), [Nova Wallet](https://novawallet.io/) and others.
This guide will be using Subwallet as an example.
2. **Using the Explorer**: Advanced users can also create an account straight from the explorer.
#### Subwallet
1. Go to [Subwallet.app](https://www.subwallet.app/) and install their browser extension. Once installed,
you should se a few different options to get started. We will create an account from scratch, although you can import
existing accounts too.
2. Subwallet will prompt you to set up a password to secure access to the accounts in the wallet. Please note that this password
**DOES NOT** control the actual on-chain account, and is merely used to open the wallet extension.
3. Next, read through and agree with all of Subwallet's conditions to get the Seed Phrase of your Avail account.
4. You will be shown your seed phrase. **Make sure to write it down and store it in a safe place**.
> **Warning**
>
> Please note that this seed phrase is exposed only one time at the time of account creation by Subwallet.
> Make sure to store it in a safe place as it is the only way to recover your account.
5. Open the `networks` menu from the top-right. You can configure which networks you want displayed by Subwallet from here.
6. Search for Avail testnets either by name or by token symbol. Make sure the network is toggled on.
> **Note**
>
> Please note `Avail` is short-hand for Avail DA mainnet, while the other option connects you to the Turing testnet.
> You can choose if you want to connect to one or both of them.
7. Next go to your extension's homepage and click on the `Get address` button.
Again, search for Avail testnets by name or token symbol, and click on the `copy address` button.
#### PolkadotJS or Talisman
1. To start with setting up your PolkadotJS wallet, you can go to the [PolkadotJS extension homepage](https://polkadot.js.org/extension/) to get started.
2. To get started with Talisman, you can go to [Talisman's docs page](https://docs.talisman.xyz/talisman/start/installing-talisman) that will show you how to set
up a wallet with Talisman.
#### Klever Wallet
1. Go to the [Apple Store](https://apps.apple.com/tt/app/klever-wallet-bitcoin-crypto/id1615064243), [Google Play](https://play.google.com/store/apps/details?id=finance.klever.bitcoin.wallet\&pcampaignid=web_share) or Huawei Store and install the Klever Wallet app. Once installed, you should see two different options to get started. We will create a new wallet from scratch, although you can restore an existing wallet too.
2. Klever Wallet will prompt you to set up a PIN to secure access to the accounts in the wallet. First you will need to set the PIN and you will need to confirm the PIN.
3. You can make your wallet even more secure by activating biometric/faceID authentication.
4. Done! Your wallet is created. You can choose to backup your seeds now or later. We’ll do it now like Klever recommended.
5. Read the security warnings and by clicking on the I Agree button you’ll see your seeds. It’s really important to write your seeds in exactly the same order as shown and keep them in a safe place.
6. Now you can write your seeds that you have written before in exactly the same order.
7. In your portfolio, click on + Tokens button and search for Avail. You just need to activate it and you’ll be able to use the Avail blockchain inside Klever Wallet.
#### Nova Wallet
1. Go to [novawallet.io](https://novawallet.io/) and install the application from either the Google Play or Apple App Store. Once installed, you will see a few different options to either create a new account, import an existing account, or connect a hardware wallet. In this case, let’s create a new account.
2. Select “Create a new wallet”.
3. Input your wallet’s nickname and select “Continue”.
4. Review the pop-up alert and then select “I understand”.
5. Make a copy of your Mnemonic Passphrase. Make sure to write it down and store it in a safe place, then select “Continue”.
6. Input your Mnemonic Passphrase in the correct order and then select “Continue”.
7. You have now created your wallet in Nova Wallet and can access the Avail ecosystem!
#### Using the explorer
> **Warning**
>
> Please note that you won't be able to use the account created on the explorer to claim your rewards.
1. Navigate to the [Avail Explorer](https://explorer.availproject.org/).
2. Once on the explorer, go to `Accounts -> Accounts` in the navigation bar.
3. Click on the `+Account` button on the right-hand side to initiate the account creation process.
### Click on the accounts dropdown in your wallet extension
### Click on `Attach account`
### Select the `Connect a ledger device` option
### Search for the `Avail recovery` app and click on `Connect`
### You can now select as many or as few of your ledger accounts to your Subwallet extension wallet
> **Note**
>
> **NOT ABLE TO SELECT YOUR ACCOUNTS?**
>
> 1. It is important to remember that the `Avail recovery` app will derive the same set of addresses as the `Polkadot` ledger app to give you access to your funds.
> 2. This means if your wallet already has that same ledger address connected via the `polkadot` ledger app, you will not be able to import it once again via the `avail recovery` app.
> 3. To get around this, you can temporarily delete the polkadot ledger address from your wallet and then re-add it via the `avail recovery` app.
> 4. This does not remove the address from your ledger device, just disconnects it from your wallet.
> 5. Now you should be able to import the same address via the `avail recovery` app.
### Multisigs
You can use the [avail-apps](https://explorer.availproject.org/#/accounts) explorer to set up and start using a multisig wallet on Avail DA.
This guide will show you how to do so.
> **Note**
>
> **PREREQUISITES**
> The only prerequisite is that you have access to one or more Avail DA accounts.
> Refer to our docs on [setting up an Avail wallet](/docs/da/user-guides/accounts) for more details if needed
## Create a multisig wallet on Avail DA
### Import the signatory accounts
You need to import into the explorer all the accounts you want added as signatories to the multisig.
There are two ways to do this:
#### Via address book
1. Go to the [`addresses`](https://explorer.availproject.org/#/addresses) page of the explorer.
2. Click on `Add contact` and save any addresses you want.
#### Import a json file
1. Create a json file with all the Avail DA addresses you want to import.
The syntax is as follows:
```json
[
"add1",
"add2",
"add3"
]
```
2. Save the file. This will be of use later.
> **Note**
>
> This method is suitable if you have a large number of addresses to import.
### Start setting up the multisig
Go to the [accounts page of the avail-apps explorer](https://explorer.availproject.org/#/accounts), and click on `Multisig`. This will give you a UI interface
that will allow you to configure your multisig wallet.
> **Note**
>
> DOUBLE CHECK
> Please note that a multisig account created on one network won't be created automatically on another. This
> tutorial is based on he Turing testnet, but will work just as well for Avail DA mainnet too.
### Configure the multisig
1. Select all the signatories you want to include in the multisig wallet.
You can do so either by:
* Importing addresses from your address book, or,
* by uploading the json file outlined in `step 1`.
2. Select the `threshold` value for the multisig. It represents the minimum number of addresses that need to approve a transaction
for it to be executed. A `threshold` value of `2` in our case would mean that any `2` of the `3` signatories can perform
a transaction from the multisig.
3. Choose an appropriate name for the multisig.
4. Click on `Create`.
> **Note**
>
> **BUT WHAT OF OTHER SIGNATORIES?**
> An obvious question that pops up is how will other signatories import the multisig wallet into the avail-apps
> explorer on their own machine?
> Due to the way the `multisig` pallet works on Avail DA, a multisig derived from the same set of addresses and the same `threshold` value
> will always have the same address.
> Thus, all signatories can simply create a multisig on their machine with addresses of all the other signatories along with a constant `threshold value` to derive the same '*multisig address*'.
> Alternatively, a single json file with all signatories can be created and shared among all signatories.
> **Note**
>
> The next steps will take you through using your multisig wallet for the first time. Please send some tokens to
> the multisig's address before proceeding.
> **Warning**
>
> Do not use multisig calls for Avail-to-Ethereum bridge sends. Bridge sends must be submitted directly with `vector_sendMessage`; wrapped bridge sends are rejected.
## Use a multisig wallet on Avail DA
### Create a transaction to transfer funds
You should now be able to see your new multisig account created under a seperate category on the
[accounts page](https://explorer.availproject.org/#/accounts). Click on `send` to start creating a new transaction.
Enter the recipient and the amount to transfer, and click on `Make Transfer`.
### Sign and submit the transaction
You will now be able to sign a `balances.transferKeepAlive` transaction from the multisig account.
This extrinsic allows you to transfer funds from one account to another.
1. A transaction for a multisig can only be created via an approved signatory. Choose one from the `multisig signatory`
dropdown.
> **Warning**
>
> PLEASE NOTE
> You can only sign a transaction for the multisig from the signatory accounts you have access to.
> If you don't have access to an authorised signatory, you can't create, approve, or reject a transaction
> for the multisig.
2. Copy the hexadecimal value of the `multisig call data`. This value will be needed later on.
3. Make sure that the `sign and submit` on the bottom-left option is checked. Finally, click on the `Sign and Submit`
button on the bottom right.
### Approve and/or execute the transaction
Now that a transaction has been created, other signatories have the choice to either:
1. Approve the transaction, or,
2. Reject the transaction.
You will see a pink icon next to your multisig wallet that indicates a pending transaction. Click on 'View Pending Transactions' to take a look.
Click on `approval type` to simply approve or reject the transaction.
1. Our `threshold` value was set at `2`, and we already have one approval in form of the signatory that originally created
the transaction.
2. Thus, an approval by just one more authorised signatory will execute the transaction that will
transfer
`10 AVAIL` to the recipient.
But what if you simply want to approve the transaction without executing it? Avail DA's multisig implementation
allows for this functionality too.
Let us say you are the final signatory whose approval will mean the transaction has enough approvals
to be executed.
But you don't want to execute the transaction just yet.
*You only want to approve it, and let some other signatory execute it later on.*
#### Approve
1. If a signatory wants to approve the transaction without executing it, they don't need the `multisig call data` value.
2. Make sure the `multisig message with call` button is unchecked, and click on `Approve`.
3. Then, click on `Sign and Submit` and execute the transaction.
> **Note**
>
> **POINTS TO NOTE**
>
> 1. After the `threshold` value of minimum number of approvals has been met, any signatory can execute the transaction.
> 2. You cannot execute the transaction without the `multisig call data` value.
#### Approve and Execute
3. Paste the `multisig call data` you copied in the second step into the empty column.
4. Click on `Approve`.
5. Click on `Sign and Submit`.
6. Depending on how you have connected the signatory account to the `avail-apps` UI (ledger seed phrase, wallet extension),
you might have different transaction approval interfaces. But once you approve it, funds should be successfully transferred from the multisig wallet.
> **Note**
>
> Needless to say, you will, as a signatory, be able to execute the transaction only if you are the last signatory required to meet the `threshold` value.
{/*
## 2nd way to use a multisig wallet on Avail DA (for advanced users)
Let us go through the same process as before, i.e., executing a transaction from our multisig wallet
to transfer funds, but using the `extrinsics` tab instead. */}
### MetaMask Snap
## Introduction
MetaMask is one of the most popular wallets for Ethereum and other EVM-compatible blockchains out there.
MetaMask Snaps is an open source system that allows developers to create a custom '*Snap*'
that can be installed into a user's MetaMask wallet to extend it's functionality for different chains.
You can check out [MetaMask website](https://metamask.io/snaps) and [MetaMask docs](https://docs.metamask.io/snaps/) for more information.
The Avail snap will allow you to easily interact with Avail DA from within your MetaMask wallet.
We are actively working on adding more features to the Avail Snap, so stay tuned for updates.
## Using the Avail Snap
### Install the Avail Snap
Go to [the official MetaMask snaps store](https://snaps.metamask.io/snap/npm/avail-project/avail-snap/),
and click on '*Add to MetaMask*'.
Grant the required permissions to the Avail Snap to complete the installation process. Once the installation is complete,
your screen should look like this:
### Use the Avail Snap
> **Note**
>
> The Avail Snap generates an address for you based on the seed phrase embedded into your
> MetaMask wallet. Thus, if you transfer the same wallet to a new system and install
> the Avail Snap again, you will derive the same address.
Go to [snap.availproject.org](https://snap.availproject.org/), which is a UI interface that
allows you to conveniently use the Avail Snap.
Connect your metamask extension to this webpage by clicking on '*Connect with MetaMask*'.
Once connected, you will see your derived address and its balance on screen:
> **Note**
>
> **PLEASE NOTE**
>
> 1. You will need to send some AVAIL tokens to your new address before being able to make a transaction with it.
> 2. You can toggle between Avail DA testnet and mainnet by using the dropdown on the top right. Make sure to select the correct network.
### Make a transaction
Click on *'send'* , enter an amount and a recipient, then approve a transaction on Avail DA from within your MetaMask wallet.
> **Note**
>
> THE BRIDGE UI
> Please note that the `bridge` button takes you to a different interface that you can
> use to transfer tokens between Avail DA and Ethereum.
> The bridge UI does not yet support the Avail Snap.
## FAQs
### Why should I use the Avail Snap at all?
MetaMask is an EVM-compatible wallet that supports 20-byte hexadecimal addresses derived from seed phrases and/or private keys.
Avail DA meanwhile uses the [SS58 address format](https://docs.substrate.io/learn/accounts-addresses-keys/#address-encoding-and-chain-specific-addresses).
The Avail Snap makes it possible for you to conveniently interact with Avail DA from within your MetaMask wallet.
### How does the Avail Snap work?
[MetaMask Snaps](https://metamask.io/snaps/) is an open source solution designed to extend MetaMask's functionality.
The Avail Snap derives an SS58 address using your MetaMask credentials and allows you to sign transactions
on Avail DA through an easy-to-use UI interface.
### What if I switch to a new system?
The Avail Snap generates an address for you based on the secret recovery phrase in your MetaMask wallet.
Thus, if you transfer the same wallet to a new system and install the Avail Snap again, you will derive the same
address.
### Are my keys safe with the Avail Snap?
Please note that the Avail Snap does not store your private keys.
### Has the Avail Snap been audited?
Yes, the Avail Snap has been audited by [SayFer](https://sayfer.io/).
### How do I reach out to the Avail team if I have any questions related to the Avail Snap?
We are always happy to help out our users. You can reach out to us on [Discord](https://discord.gg/AvailProject).
### Bridging
- [**Bridge b/w Avail & Ethereum**](/docs/da/user-guides/bridge-avail/avail-ethereum)
- [**Bridge b/w Avail & Base**](/docs/da/user-guides/bridge-avail/avail-base)
- [**Bridge b/w Ethereum & Base**](/docs/da/user-guides/bridge-avail/ethereum-base)
### Using the Explorer
> **Note**
>
> The Avail network has two main explorers that can be used to browse the network:
>
> 1. [Avail Apps explorer](https://explorer.avail.so/): A dev-focussed explorer with powerful tools to work with the network.
> 2. [Subscan explorer](https://avail-turing.subscan.io/): A simpler, and recommended way to explore the network for most users.
>
> This tutorial will focus on helping advanced users and devs get started with the Avail Apps Explorer.
## Switch networks
#### AvailApps Explorer
> **Note**
>
> The Avail Apps explorer currently supports [Avail mainnet](https://mainnet.explorer.availproject.org/) and [Avail Turing testnet](https://turing.explorer.availproject.org/).
To switch networks:
1. Click on the `Network name` on the top-left.
2. Depending on the network you are on, click on `live networks -> Avail DA network`, or `test network -> Avail Turing testnet`.
3. Click on `Switch`.
#### Subscan Explorer
> **Note**
>
> The Subscan explorer currently supports [Avail mainnet](https://avail.subscan.io/) and [Avail Turing testnet](https://avail-turing.subscan.io/).
To switch networks:
1. Click on the drop-down near the top-right.
2. Click on the network you want to switch to.
## Look up the details of a particular transaction
> **Note**
>
> 1. Due to how the network is designed, it is not possible for the `AvailApps` explorer to query a transaction's details using just it's hash directly from a node.
>
> 2. The `Subscan` explorer however, makes it possible to do so, since it queries from a dedicated indexer
> built on top of Avail to support this feature.
#### AvailApps Explorer
> **Note**
>
> **Search for a txn using it's `block number`/`block hash` *AND* it's `transaction hash`**
1. Search for the `block number` or `block hash` of the block your transaction was included in.
2. The explorer then fetches all transactions from that specific block. Click on the hash of the transaction you are interested in to get a detailed view.
#### Subscan Explorer
> **Note**
>
> **Search for a txn using just it's `transaction hash`**
1. Just paste a`transaction hash` and click the `search` button.
2. The explorer then fetches the transaction details and displays them.
## Create accounts within the explorer
#### AvailApps Explorer
The `AvailApps` explorer can be used to add or import Avail accounts into the explorer.
To go to the page, click on the `Accounts` tab on the top-left, or click [this link](https://explorer.availproject.org/#/accounts).
1. The `accounts` section shows any accounts created straight from the explorer. You don't need any wallet extensions to create or use them.
2. The `extension` section shows any accounts connected to the explorer from wallets like `Polkadot.js`, `Subwallet`, `Talisman`, etc...
The following gif shows you how to create an account straight from the explorer:
You can do a few things here:
1. Create a new account using a `mnemonic` or by clicking on the `+ Account` button.
2. Import an account via an encrypted JSON file.
3. Connect extension accounts from wallets like `Polkadot.js`, `Subwallet`, `Talisman`, etc...
4. Create a multisig account. We have covered instructions to do so [in our docs here](/docs/da/user-guides/avail-multisig).
5. Create a proxy account. We have covered instructions to do so [in our docs here](/docs/da/user-guides/proxies-on-avail).
6. The `AvailApps` explorer also allows you to use hardware wallets to safely connect cold accounts. We have covered
instructions to do so [in our docs here](/docs/da/user-guides/ledger-avail).
> Any of these accounts that you connect can be used to sign transactions on the network. Which is something we will cover in the next section.
## Using the explorers to interact with the network
#### AvailApps Explorer
Wrt interacting with the network, the `AvailApps` explorer can be used to:
1. Query data from the network by calling `Chain State` or `RPC` methods.
2. Send transactions to the network by signing and submitting `Extrinsics`.
You can find them within the `Developer` tab.
> **Note**
>
> **WHAT ARE PALLETS?**
> Avail organizes its runtime functionality into `pallets`. Each pallet is a collection of calls and extrinsics of a specific functionality.
> For example, the `data_availability` pallet contains all the calls and extrinsics related to querying and submitting data to the network, and so on.
> Some methods might be grouped into seemingly unrelated pallets for technical reasons, but this largely holds true.
>
> To look for a particular method within the `AvailApps` explorer, you need to know the pallet it belongs to.
### How to use the explorer to query the network
Let us learn how to query the network using the `AvailApps` explorer by querying the balance of an account.
1. Either go to the `Chain State` methods menu from within the `Developer` tab or click [on this link](https://explorer.avail.so/#/chainstate).
2. The balance of an account can be queried by calling the `account(AccountId32)` method from within the `system` pallet. Select the `system`
pallet from the dropdown on the left, and the `account(AccountId32)` method from the dropdown on the right.
> **Note**
>
> **THE `include option` TOGGLE**
> This toggle allows you to enter params for a method when it is toggled on.
> You can also call methods without passing a param by keeping it off. \
> But `system_account` method won't return anything without an `AccountId32` param being passed to it, so we will keep it on. \
> **Hot tip:** Try calling the `dataAvailability_appKeys` method with the `include option` toggle off to see what happens.
3. Either paste the address of an account in the `AccountId32` field or select an explorer-connected account from the dropdown.
4. Leave the `blockhash` field empty (This will query the latest balance of the account), and click on the `+` button near the top-right.
5. And that's it. You just used the `AvailApps` explorer to query the balance of an account on the Avail network. You can query other methods in a similar way.
### How to use the explorer to send transactions to the network
You can also use the `AvailApps` explorer to sign custom transactions/extrinsics and submit them to the network.
We have covered different examples of doing so in our docs. Here is one of them:
[Submit data to a particular `AppID`](#how-to-submit-data-to-my-appid).
### Bonus: How to query chain constants using the explorer
1. The `AvailApps` explorer allows you to query the current values of all of it's runtime constants by going to the constants tab within
`Developer -> Chain State`.
2. For example, to query the current value of the `existentialDeposit` of an account on Avail, which is the minimum amount required by an
account to exist on the network, you can call the `balances_existentialDeposit` constant.
> P.S: The balance displayed is in `attoAVAIL`. 1 `attoAVAIL` = $10^{-18}$ `AVAIL`.
3. You can look up any other constant in a similar way.
#### Subscan Explorer
The `Subscan` explorer leverages it's dedicated indexer to enable users to browse the network in some neat ways.
1. You can browse network activity more conveniently by using different filters.
> **Note**
>
> * `Blocks`: Browse blocks by number.
> * `Extrinsics`: Browse all extrinsics submitted to the network.
> * `Transfers`: Browse all extrinsics that involve `AVAIL` token transfers.
> * `Data Submission`: Browse all data submissions to the network.
2. The `Staking` section allows you to browse the staking activity on the network.
3. The `Governance` section allows you to browse all governance-related activity on the network, including all past proposals.
4. The `Tools` section supports some useful features:
> **Note**
>
> * `Charts`: Some charts for a visual representation of network activity.
> * `Account Format Transform`: Transform an account address into different formats supported by various Substrate-based chains.
> * `Price Converter`: Lookup the historical price of `AVAIL` by `block number` or `timestamp`.
> * `Runtime`: Browse data related to runtime extrinsics.
## Working with App IDs in the explorer
The following sections walk you through querying, creating, and submitting data to App IDs using the AvailApps explorer.
### How to check the next available `appID`?
Anyone can create their own `appID` on Avail DA. Let us first check out the next available `appID` on the network.
1. Make sure you're on the `chain state` section of the explorer. You can access it by [simply clicking this link](https://explorer.availproject.org/#/chainstate),
or by navigating to it through the `developer` tab near the top right.
2. Within the `dataAvailability` pallet, select the `nextAppId` method.
No need to pass any params, just click the `+` button next to the method name.
3. You will be returned the next available `index`/`id` for a new `appID`.
### How to register my own `appID`?
1. Make sure you have one or more Avail DA wallets connected to the explorer. If you don't know how to do so,
you can follow our docs on [setting up a new wallet](/docs/da/user-guides/accounts#creating-an-account-on-avail-da).
2. Simply [click this link](https://explorer.availproject.org/#/extrinsics) OR navigate to the `extrinsics` section of the explorer through the `developer` tab.
> **Note**
>
> Please note that the `Developer` tab does not show the `extrinsics` section at all if you don't
> have a wallet set up on the explorer or an extension wallet connected to it.
> So make sure you have an [Avail DA wallet set up](/docs/da/user-guides/accounts) before moving forward.
3. Select the `dataAvailability` pallet, and the `createApplicationKey` method.
4. Enter a `key` for your `appID`. It can be anything you like, really.
5. This is how it should look like in the end:
6. Click on `Submit Transaction`, and then click on `Sign and Submit` in the box that pops up.
> **Note**
>
> **DO NOT CHANGE THE `appID` FOR THIS TRANSACTION**
>
> 1. Each and every single transaction on Avail DA has an `appID` associated with it, which is **greater than or equal to** `0`.
> 2. A transaction or data submission with the `appID` of `0` is used for **chain-level** operations.
> 3. This is what we need to use for creating a new `appID`, since the act of creating a new `appID` has nothing to do with a specific '*app*' on Avail DA.
> 4. This field would instead have been a positive integer if we, for example, were submitting data to a specific application on Avail DA.
7. Authorize the transaction through your wallet, and you're done! You've successfully created your own `appID` on Avail DA.
8. You can verify `7` by using the steps covered earlier to query the `appKeys` method :)
### How to submit data to my `appID`?
You can submit data to your, or any other `appID` on Avail DA using the explorer by calling the
`submitData` extrinsic from within the `dataAvailability` pallet.
1. Make sure you have one or more Avail DA wallets connected to the explorer. If you don't know how to do so,
you can follow our docs on [setting up a new wallet](/docs/da/user-guides/accounts#creating-an-account-on-avail-da).
2. Simply [click this link](https://explorer.availproject.org/#/extrinsics) OR navigate to the `extrinsics` section of the explorer through the `developer` tab.
3. Select the `dataAvailability` pallet, and the `submitData` method.
4. Enter a random `data` string that you want to submit to your `appID`, and then click on
`Submit Transaction`.
5. Fill in the `AppID` that you want to submit the data to. Click on `Sign and Submit` to authorize the transaction through your wallet.
6. Wait for the transaction to be included in a block and then open the detailed view of the block.
7. Click on your specific transaction to see it's details. This is what it should look like:
## Wrapping up
We will update this page with more examples and information as we go along.
Feel free to join [our Discord](https://discord.gg/AvailProject) and suggest any additions that you would like to see here.
### Identity
## Introduction
Avail allows you to set canonical on-chain identities for your accounts via the `identity_setIdentity` extrinsic. \
The AvailApps explorer provides a convenient UI to set an identity for your account, which is what we will be doing in the
next section.
### Fill out the fields that you want to set
Fill out at least 1 or at most all of the available fields.
All the fields are optional as long as any one of them are filled.
### Submit the transaction
Click on `Set Identity`. Make sure the `appID` is `0`, and click on `Sign and Submit`.
> The account will now have a registered on-chain identity which you can clear to recover the bonded AVAIL tokens.
### Proxies
## Introduction
A *'proxy'* of an account on Avail DA is simply another account on the network that has the power to sign transactions on behalf of the
original account, also known as the *'proxied'* account.
We can also configure the proxy to only have permission to sign a subset of all possible transactions on behalf of the proxied account.
We will learn more about this later.
> **Note**
>
> **MAKE SURE YOU'RE COMFORTABLE WITH THE LINGO**
>
> * *'Proxy'* - A proxy is an account that has the power to sign transactions on behalf of the proxied account.
> * *'Proxied'* - Refers to the original account that the proxies are signing for.
> * *'Any proxy'* - An account that has the power to sign any type of transaction on behalf of the proxied account.
> You can have many different types of proxies on Avail network. Refer to [this section in our docs](/docs/da/user-guides/proxies-on-avail/avail-proxy#proxy-types) for more information.
## 'Proxy' vs 'Pure proxy'
You can create two types of proxies on Avail DA:
### Proxy accounts
When creating a proxy for an account you own, you choose the exact address of the proxy, which may or may not
be an address that you control.
You can do this using the `proxy.addProxy` extrinsic. The Avail Apps explorer provides a convenient UI abstraction for this,
instructions for which can be found here:
- [**Proxy accounts**](/docs/da/user-guides/proxies-on-avail/avail-proxy)
> 👉 The key principle to note here that is that you can create a proxy account that is not under your control.
3. Once installed, this is what your ledger device's homepage should look like:
### Open the Avail app on your ledger device
> **Note**
>
> Please note that you will need to have the Avail app open on your ledger device to interact with Avail DA in any capacity.
This is what your ledger device should display when the Avail app is opened:
### Derive an Avail DA account online using your ledger device
1. Go to the [settings tab of the Avail apps explorer](https://explorer.availproject.org/#/settings).
2. Click on `manage hardware connections` and select `Attach Ledger via WebUSB`, then save the changes.
3. Go to the [accounts tab of the Avail apps explorer](https://explorer.availproject.org/#/accounts).
4. Click on `From Ledger`.
5. A form will pop up. Give your derived account a random name.
6. Choose a top-level and a second-level derivation for your account. We'll be going with `0` and `0` respectively.
> **Note**
>
> Any account address generated from your ledger will be a unique combination of your ledger-device's
> seed phrase, the top-level derivation, and the second-level derivation.
> This means if you re-connect to the avail apps explorer with the same ledger device in the future (that has not been reset), and use
> the same top-level and second-level derivations, you will get the same account address.
7. This is what the accounts tab should look like after you've derived a hardware account:
8. Make sure to send some AVAIL to this account to interact with Avail DA.
### Sign a transaction on Avail DA using your ledger device
1. Click on the `send` button alongside your ledger wallet.
2. Enter a recipient's address and an amount to send.
3. Click on `Make Transfer`.
4. Make sure the app id is `0` if you're performing a simple transaction.
> **Note**
>
> Please note that non-zero app ids are used to submit data to Avail DA.
> For all top-level/simple transactions, the correct app id is `0`.
5. Click on `Sign and Submit`.
6. At this point the explorer UI will wait for a signing/rejection of the transaction from your ledger device.
7. You can verify important details of the transaction from your ledger device, including the destination address and the amount of AVAIL being transferred.
This is what it should look like:
8. Once you are done verifying, `Approve` or `Reject` the transaction using the buttons on your ledger device.
9. Once the transaction has been finalised, you will see a success message on the explorer UI:
### Support
If you face any issues while using your ledger device with Avail DA, please feel free to reach out to us on our [Telegram](https://t.me/AvailCommunity) or [Discord](https://discord.gg/AvailProject).
## Add your Ledger account to an extension wallet
If you have set up your ledger device and want to use it through a dedicated Avail wallet, this section is for you.
We have included instructions for connecting a ledger account with Subwallet & Talisman, but the process is similar for other wallets.
> **Note**
>
> If you are looking for instructions on getting started with an Avail wallet, you can refer to our [accounts guide](/docs/da/user-guides/accounts/#creating-an-account-on-avail-da).
#### Subwallet
### Prerequisites
Make sure your ledger device is unlocked and the Avail app is open.
### Click near the top to expand the list of accounts
### You can now select as many or as few of your ledger accounts to your Subwallet extension wallet
### Click on `Connect Ledger device` to finally import your selected accounts
#### Talisman
### Prerequisites
Make sure your ledger device is unlocked and the Avail app is open.
### CLick on the `+` sign next to the accounts tab
### Click on the `Connect` tab and then on `Connect Ledger`
### Select the `Polkadot` option
### Search for the `Avail` app and click on `Connect`
> **Note**
>
> **MAKE SURE YOUR LEDGER DEVICE IS OPEN THROUGHOUT THE PROCESS**
### You can now select as many or as few of your ledger accounts to your Talisman extension wallet
### Click on `Continue` to finally import your selected accounts
### Staking & Governance
Stake AVAIL tokens and participate in governance. Start with [The AVAIL Token](/docs/da/user-guides/staking-governance/overview) to understand tokenomics, then explore staking and governance.
- [**The AVAIL Token**](/docs/da/user-guides/staking-governance/overview) — Token supply, distribution, and utility on the Avail network.
- [**Stake on Avail**](/docs/da/user-guides/staking-governance/stake-on-avail) — Nominate validators and earn staking rewards.
- [**Avail Governance V1**](/docs/da/user-guides/staking-governance/governance-on-avail) — Propose and vote on network changes through on-chain governance.
### Get current Ethereum head
## Request
* `Path`: `/eth/head`
* `Method type`: `GET`
## Example Request
#### CURL
```bash filename="CURL"
curl https://turing-bridge-api.avail.so/eth/head
```
## Example response
```json filename="Example JSON response"
{
"slot":4454752,
"timestamp":1709191840,
"timestampDiff":1716
}
```
### Get current Avail head
## Request
* `Path`: `/avl/head`
* `Method type`: `GET`
## Example Request
#### CURL
```bash filename="CURL"
curl https://turing-bridge-api.avail.so/avl/head
```
## Example response
```json filename="Example JSON response"
{
"data":{
"end":512738,
"start":488581
}
}
```
### Check liveness of server
## Request
* `Path`: `/`
* `Method type`: `GET`
## Example Request
#### CURL
```bash filename="CURL"
curl https://turing-bridge-api.avail.so/
```
## Example response
```json filename="Example JSON response"
{"name":"Avail Bridge API"}
```
### Get bridge deployment details
## Request
* `Path`: `/info`
* `Method type`: `GET`
## Example Request
#### CURL
```bash filename="CURL"
curl https://turing-bridge-api.avail.so/info
```
## Example response
```json filename="Example JSON response"
{
"availChainName": "hex",
"bridgeContractAddress": "0x1369A4C9391cF90D393b40fAeAD521b0F7019dc5",
"vectorXChainId": "11155111",
"vectorXContractAddress": "0x570f6a1936386a4e060C2Daebbd0b6f5C091e13f"
}
```
### Get Merkle proof for a particular extrinsic
## Request
* `Path`: `/eth/proof/:blockhash?index=`
* `Method type`: `GET`
## Example Request
#### CURL
```bash filename="CURL"
curl "https://turing-bridge-api.avail.so/eth/proof/0x5bc7bd3a4793132007d6d0d9c55dc2ded2fe721a49bd771c1d290e6a3c6ec237?index=5"
```
## Example response
```json filename="Example JSON response"
{
"blobRoot": "0x511030804f9768c9d5c4826cdc7eba25ba0fd8e73ea32467e5fad547397620f8",
"blockHash": "0x5bc7bd3a4793132007d6d0d9c55dc2ded2fe721a49bd771c1d290e6a3c6ec237",
"bridgeRoot": "0xf6c807bc73a637957a61d620bd5e4ef8c7dd234e5fc96dfb6d6041bbe2947782",
"dataRoot": "0x2179e18ee112b080794b40f2239d77041c715ad7392d9fce054b7c10eacd4ebc",
"dataRootCommitment": "0x41cfe14b2e229cc5b4ee0cb7c3c909e1f78ae9e32f986e7496bfd4e007e06519",
"dataRootIndex": 48,
"dataRootProof": [
"0x0395f21560a9ccc1f2aa972601250256fbdb20fd936e1723397ff8d5e4f07b5d",
"0x1e91eb5ce2802373a583ce83898e8b4c1bb648e3c76bad87820a197b73b6d23b",
"0xd49b33b5754aa6c9549e9677e4c646bd4e7d500a2ab9761cffff5363f4608ac7",
"0x575858cb3bb948af2d8c4582310f951eb798281f71e913e044c6c415031f58a3",
"0x353fe475ab9b0e00c3bfae8598fef61ac2921a7928b21ad45b6594c023611156",
"0x4cb574d05c6606d2509ec6849e0cb53d04c5eead1cdbed4704018da938df5460",
"0xd88ddfeed400a8755596b21942c1497e114c302e6118290f91e6772976041fa1",
"0x87eb0ddba57e35f6d286673802a4af5975e22506c7cf4c64bb6be5ee11527f2c"
],
"leaf": "0xe17de7631392427460102691ba8a22adf5fb410548e50d6c636bf1f96840c3c3",
"leafIndex": 0,
"leafProof": [
"0x00017cadd87ec12039f98d646afaa33ed843056ad12f5e971cc81be15d00c26f",
"0xd046caabde74922f9d69e9fd33de6d3b9ee0f5c536183c4f4259f078afda538a"
],
"message": {
"destinationDomain": 2,
"from": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
"id": 256491151949829,
"message": {
"fungibleToken": {
"amount": 5000000000000000,
"asset_id": "0x0000000000000000000000000000000000000000000000000000000000000000"
}
},
"originDomain": 1,
"to": "0x0000000000000000000000000000000000000000000000000000000000000000"
},
"rangeHash": "0x21c402a3ccf8df26cb720c6d2fb409f04c809adef7a9a852e463cca83588f4fb"
}
```
### Get storage proof for a block
## Request
* `Path`: `/avl/proof/:block_hash/:messageId`
* `Method type`: `GET`
## Example Request
#### CURL
```bash filename="CURL"
curl "https://turing-bridge-api.avail.so/avl/proof/0x7963d8403d137cb5560e2436df07c233d18030b5f3f0c61b85083e2a8f2b5e55/1"
```
## Example response
```json filename="Example JSON response"
{
"accountProof": [
"0xf90211a04ea3386c3564d92c70c842f4fe40a382ab0c0915bd52f1cfdf515e7df40f6365a05fd188dd610941144f5367487b343528f30b6fe1713e14c489a925d31b76de8ea081a4596748d2119583d96af1f6459bfc4d4cf48e5cf9f4171bb0f15b54bfc705a0934bf30f9e4643c1e8cabd31b65867d5dce6702ff922d5d5f88edd77c16eddf8a020c236a887760702595f069baa5c20a5d7f7ff56e99e4f2291e6c383ec2f1376a0a4c5d6569cf6acb8b7b744bdb847ee84c7a250a05858f21c4b71e892e0f6368ca0431a25d2f4d04d92b7f663f91b65029bd2a443fdcd71d6a5d1cd2bad5f937da5a09d5da24c3c97ebd7ed4897206e30464414bdaf91fb633ef6e5aa61ec4573b829a0e1850f0a51e6f8fb4e7b7d0a592a478e4fd4f55132faad2e05c774f2c5bf3722a0e437d19bee3cdd31e6a54da59dd1730d20ad59b1e816ba304b0f8cf89fa62697a07c9058190b5603de7af44f45d2654832a5e5186db18b28514101f5df81287a27a08637a03272d24e7d380f3d68a38525d0348cce5fe90ae32f2b51149badd96f75a0d45f94f513a8918bafb074ac20f951e6ddd59cfa414550ea7af155ea7530e386a03dc457251a135a4002731a17ee72e722897a64509dd108eeb729bb1d9a84bf3ca0e1834ab71a27a983540fee14db56a40c26e3936db6b76d950a117acd5d2a03fea053388d24ffe072f62c6ed5dc8d8e286e167648a5bed4f9a1445df2b2581a589880",
"0xf90211a05f1dfe6f285811ddc2b5c1b2e0b4c9715586274627a60885abf66fe60f58f39ea098709a8cac54a765fa8b09b12849171bc2aadece08d4d21e2631efb92e422a72a09456842fb2f41eeaad70f98549983ec28ac5cc97b2bacd325a341bf8fecbd3fda012f6579824d8706f219fab4e6209270b3c5a7f9b9b10434422173bee004ebf87a0cad660f5066719c1e57fa895b385aedb678d89843f93fa9d284137cce585d912a08aee33972b41bd2c81bb805877f91b5c720c518551071c8c7b7b5035fc855dcaa0fe78af4efca09613a5b166012ad59ce6450d8f612d872010b8cb2cfce5171e01a0ed34274b556d95bc83b368a313d81e2418c84435e094626f568294de2c6adda3a0c4a8516496de7bd739485f7f0ea764e5f1e64f18ea24d5c2662df9321ad476b0a0c3ac05b241ad4ce2e59c05d280a56cdcaa38b8d974d0086a517ea0e71f47dbbba0c786b94bc71965e950e2cddbc6dc3d20b9527f14ac6720dffd93531f58cbb2caa0db4936424a52afb5f811937e21c36dbfc115f36167f57ea0f0770ba5b2b01509a08bfc560bf436ebfd1b9b2a16b38c37fdef7b27b5c5facf3d8487034100e04da3a0d19c58734f31adc98c08131a3f441d4945c63a569d381265517fb270d149fcd9a0a49a515f1d226b9a55079dd09128e8d068ce4473fc2afc7ce83ca73b4a4aeca8a039f4a70c5da7a6f9a75ccfbfa4e4660f367d83ed133633a09d8d85f3b81619b080",
"0xf90211a013013c8d88c90029dae1eb17e9fde9d31aa12a845f977d5b05edfbb836490ed1a08313217b9700aa20e3f2bca060da9c6986794e32e39ee8378c5fc090ea3900c4a0bb6f74f7517cc6d53e1ac28cda4b7492460eac8ad25dae2e6f5dd83054975f5aa06591f5961ce401397d1b7ca8ace8c514f0711029a4804afc5dff746535f4b310a0acb9ff577f6e255b1739bdca46b3fca567678334cef7a7c3459110d398117ca0a0ca52f676d720f2148ea17a8949d8456043eca88e500c0455de24bd5f97c4574ba043f8dbbd691453a0601664d5a35b89b7980c679924f93427d446ccb4b8f54bfba0429ee0cf4db61c968b343ade1502260068beaa87dc31e673c3abeaad60dbe7a5a03e27446763b24c289f918b1710dd069019fb95cd822997fb6fbc1db75ac8b0eca0fdf20b9898a99a2378bb653195060908595370eb56d905306ca1d1260d5c4120a0c63d1fb8a5be22724ea48117eab3b87f9a2ff76c6dec7f3568ddc16098f31b68a0e527b82ba67b4d9299c0e11f48362894ff615bf39e36ccde2d4e13b636262833a008b21c1e3dc4c5938833ed344842aff4a75297019736e1b66820a959d3092561a02bcb48ab6bf1b0b426008ab0919010b847473a3710806632bed77f05d10b2f5ca09b61c79db573dcc92d61a101051e2cffc43389cbffb39cba671fd5a706c26cd1a030051e73e7a062b2812459e8cd4c2db94c408f2dc706fc16ed632cda8707f3bd80",
"0xf90211a007df9be996660f9f91495c59b998832068088ae9034c5b04639694168b9571e6a0aa1dc52398e74cf48729ec879a6ee91c2e73cc73c076f953dda4dfe580ff05e3a0afc1d0a6d1d8723d5c16d5b25673eb3f4d05ef1466612ee9182781bbe987611ea038064f5d9c62106631b05c606352db759e3b535cdafeafb16638c9515731a7cba06800f0958bb61b89dd4bb02eb3da4bf6c14ad00b4a48a66019b0e6d15cc84ee1a08c149b7166f15e51a524ee32ea212f60d6df6a800e01d4fa22ffede5a39ee9e5a093922185d4bdbe12d5e5c62194739038e89b01d67f476acc8865817ac7ed9008a016d39ae51fad6e0f060d8653d173460ed52a823010a29db6edbc042b21e78fbca0f2c153d9c2c2b50644bc8098925dbb3ed618fa7e82ebb94e40965b2c977b6811a01f01669c56000db9ac524e334dace75e9f082db5c95ed9075caacc99165abc76a04ced0f74f50c438075f4d18fe1a0bbafa324e4a5a0d5fb7865acb35c72533e4ba0c8053b16343a4f4dd43ab76abb1cac2f8e791fdb3fa9121014cf7a42151860d3a06961b3a4f6ca879e0377f734d66f930af3258e1492be0c693d395c84a311a644a0a38ea23af3ce3d1d5b485a5c264f9cffaabe184e362466de6bf6e634062f5548a062843d42cff1c276a0e11cc1c6921151b7e84b8de41a2834c0beac97f6a07de3a0609f8c69b1fc2754e2d08946285d80a5a319647acef900dd97a62d21258a035880",
"0xf90211a0aec1c4685e2c3b64c256d10b3135ef48b013524839f8373dbd0bc0eac8d7ba1fa05ab97dd3b415869a2674d9dd1744abfb45de8dffc2c302b05c1336d40c80cf14a07ad83ef3d645503b9afcf48de32fb677beef8b637aa120e6624acea518eb5b3fa030775e5e8230f409c292e2d4033a7530f83656cb67148acc599d37f782f8ef8ba013f3d308779aeb8958a612b37a07807a1783b0f99e1e5f76303fb7c3c44d622ca06e7b7e9dcfc4c24c702aef326848015731a4e20f0d8a02a401197e99c62ca1d7a0ae60461c17040fd1475fceac5e5f5528d2b972b084b4d5413f8cfb41f1ac7075a029a319fc16340bb5889952869c0184a1fc1d0427aa488dd597909671c9b41b6ca03abb30bb5daf1a503a65f2e7979f61ed288f163937406758e2a44ed7a751d216a04e9cfefe88b368b66e1da951909d6e6ce639845c19690778f6e316c9dc902d52a0c7eb14d0cf6465626d7834f200810b009aeb7b13f384c096ebe3ec503b75f4faa0ad3c0d202e74be0f188316e4e466ae7fca89b6a20994b22747b2f95febf5a449a0692d63a3756a510f8467f7da09e97da406265b4201fa4fe3577cbb887045cd6ea093b71eb86d53ddf8d13df0e7c446867dbacf096455045a2bd9690c56a443b4c3a0e712c0b14d1130db6db7edd7a93af2fc1a06d2e5793c4e54dcacca98b4cc6997a0bcc85c28e9f209b9b419e66f87bce37fbb42ba8416880935275c377d2fcebcc180",
"0xf90191a0deb916373640a76bb6056aa37e9d548908c92fb5d3ea1fc69a1c99ddeb40eb24a029b4cdce0d4f7eed71cf6f6d21f4d27ef510b3e36c7c67587e84a08b8b288de380a0cd92c24f26cec2802437f2f8e56cdd35e47ed3edc4c806540740f5bf83f1c5ffa0aadf083c80930dee9f09d295708b24f31d2f41f50e1442e32ecbf03eb5b4a707a0f5335f3280d3be255686e95e46a353a1562a8008919a0051a46fb3fcce7c53caa07f9373bba9b4111e6d4ef57fecd16526497cdeaceccdb26ae09c526b834c83c3a0d000e75b89a65aedb850451d369e3ac5bf4d7ff0d71ec5e837417c0eaf074135a0a994cad72a8a641c62979d6f94ea0087a14770876869de76ff0aba4c51b7cfc480a094b7d0ec3e0de0f4135fed0b225c1a5f09fd8660e37fa7ee3d47cdf774fe4940a06e2c53738e77dd7b3c06aada2fcd6035a8435f8edbd40e0e9856439024502a2fa000e7bef9cf8c6301c9d0aba5e61136a898292f1cbde8861987d0999358f5505f80a0c232ad4a9e338ea79c8f86fc6a83952f212b4477a031a3c24d98d5aac8ef1fac8080",
"0xf87180808080a038eace52a35a1cb3ba4dfc5a7dd4fd884d999c017dd48546779e9b1ceee867f3a07564257a73fdfa4e290ad21fe914294174996ac87095b5730370371f5ea133e980808080a0d51dbe737bf6d8c5b89bcf7724074067d2a4986c4180a5016a8bebfbc92f56e1808080808080",
"0xf8669d38b7b6c4749ee47ec3483ea3325831ccd2fbcbbbcf7cb559ed13d35a14b846f8440280a0927826564770fb917bb1bc72e196fcf2fe2601c838c744106d1691a9da45b795a0fc50d62823735da871a4b45630e8f4a5aef99c18855869762b05d4f7fac4a859"
],
"storageProof": [
"0xf90211a02b61c0a3f1012b0c3fe640d90daf8f756f30665e9763d97c2809e683f57418bca0ca985e3b14af8741416d7c735fcc856c510138e8a82edd8506e49d8cac71258ca0bfebf2d2da505708433ec9e6d7d6f5f5706b502435ad98b8429f04f497f1e79ca0481bcb4d57a33e6fdd2d824b3f0bea708c76f437b114d043da26a9b019220552a01e5139fa355fc9ab10b4901bb0a1aee4b97b21441f3a6c2ecccadd2009b6e34fa05806452c1672d430087e3aac3e49901fe6788e8d5e2db17140ed49d3e4a6e262a00bc15c11195738ae6967054b12acc80948f99d852b3a05b2572407c67e98dfaca028fa67ddfd82c094d593d0001f099cff4f5bdad51cf0d77f4e5d15243c23701fa06ddefc9d483203b04420fc19c1de59664c839a726edb7cd6d519f63444293567a0fa38292ed34577ba490dfb1335d9ee2871bf64a498d8af13eb665516bc122fc8a03b6f3c05d6c9151aa3f552d3088d12e80ab70d78ef046ddf4d311dc35fd89699a02bbf18d484d22ce32d8efb9ad5236ca770f34ca46093a062c9fd0c00fce179b1a093e4702951798f5331327b8a6a613307e12edc789dc1ddb21ba4ef185122cedda091b0434eedf92e47d68213d40c2ead10fb94f7ce34845d9b85ddc255a5586f98a0b6a8a018fe45d5a78c237915cdc4db38a151c2078e9fd72ed53481072e816366a0c4a7126e02988de7caae8abdd299cf6fbde0eb2adc9be75ded86e8ea8388dead80",
"0xf90151a0401fa10b5959532f16179be0bd2506e7f849495298c2de8fd5b8c4d63b1f2c1ca01dcc18ed03ed3183fe26600b23afedbebdd947d6b5019cc010ea359e0234afe0a050030a57a0878bb51bbd0c62d3ba0c2b782ebc5d6ec012a7a1bd0f20917558b6a0db69566205faf59c73db049a04d81f63db7d2dbafbe66ed91557e511ed0938d780a0e6114e00cb6c2aa9cf632cb93e5ccad1b4c9af79c769950743a647fe829c602ca0bcb35466c5b4c32c509da47141cb7b9c3dddff0ebcd0ea050bad4d398e2fb25f808080a054876fae9e71b3585d4e83ee48c65b366f6f13a3c1b9e2749918145eabd1c46da004531fc338c340e676badc1a99cad6ece2da3d08945f806cb7063bf3343d35f48080a0c68fcd91600b226b6c847f28d2f6ca3f60c55b1009b26e59f4d1087bb5d6fcc0a06c5aec8aa331b1f04b26a06cb64c5a6d63616d717f236d31106751bbea0d666880",
"0xf871a08eccb5e838d7d0699e06d85c472bb097d8012c44d790e5d15c5b8465c7abb88180a02581c4c4535083ecd9ea1a314216bbe948f27bccb2e997c7796a9eec8f4c3df0a0c453ceda114a9775f135a7a2687f75e753c6f814789528fb73bb8cb5dec7eac680808080808080808080808080",
"0xf8429f31265685397ec9fa17535b5603e86e2b01a583b71373e1b2cbfac2a5bff58fa1a0eb70a047920b4aa1f3a418b52e455694d4e1a2362fd7fbcf16fe53d798311beb"
]
}
```
### Bridge a message from origin to destination chain
* On-chain name of extrinsic: `vector_sendMessage` to send a message from Avail to Ethereum.
* On-chain name of extrinsic: `vector_execute` to execute a message receieved from Ethereum on Avail.
> **Warning**
>
> `vector_sendMessage` must be submitted directly. Wrapped bridge sends, including proxy, multisig, scheduler, and batch calls, are rejected and will fail validation.
## Send an arbitrary message from Avail DA to Ethereum
#### avail-rust
Let us first look at how an arbitrary message is being sent using the `vector_sendMessage` extrinsic below.
```rust
let da_call = avail::tx()
.vector()
.send_message(message, recipient, domain);
let params = AvailExtrinsicParamsBuilder::new().build();
let maybe_tx_progress = sdk
.api
.tx()
.sign_and_submit_then_watch(&da_call, &account, params)
.await;
```
## Full Example
### Sending arbitrary message from Avail to Ethereum.
Initialize the `avail-rust` SDK.
```rust
use alloy_network::EthereumWallet;
use alloy_provider::ProviderBuilder;
use anyhow::Result;
use avail_bridge_tools::{address_to_h256, AvailBridgeContract, BridgeApiMerkleProof, Config};
use avail_rust::avail::runtime_types::bounded_collections::bounded_vec::BoundedVec;
use avail_rust::avail::vector::calls::types::send_message::Message;
use avail_rust::{avail, AvailExtrinsicParamsBuilder, Keypair, SecretUri, WaitFor, SDK};
use reqwest::Url;
use serde::{Deserialize, Serialize};
use std::fs;
use std::str::FromStr;
use std::time::Duration;
#[tokio::main]
async fn main() -> Result<()> {
let content = fs::read_to_string("./config.toml").expect("Read config.toml");
let config = toml::from_str::
> **Note**
>
> Please note that you will regularly receive information related to the topics you chose to subscribe to
> for as long as the `ws` connection persists, even if you don't actually send any messages.
Every request should contain unique **request\_id** field, used to correlate request with response.
## Subscription IDs vs Request IDs
Each time you use the [`v2/subscriptions`](#v2subscriptions) method, you will receive a unique **subscription\_id**.
This ID is used to connect to the websocket server.
Each of these IDs will be of the [UUID4 format](https://www.uuidgenerator.net/version4).
Coming to requests, every request you make to the websocket server should contain a **request\_id** field,
which will need to be a UUID4 value. You can choose to use a single, random UUID4 value to send all your requests,
or you can use a unique UUID4 value for each request you send. The choice is yours.
Using a single UUID4 value is simple, but using a unique UUID4 value for each request can help you
correlate each response with a unique request.
The Avail LC API was designed with dev experience in mind, and this way you can choose the way that suits you best.
### Submit data to Avail DA
> **Note**
>
> **LOOKING FOR INSTRUCTIONS ON HOW TO RUN YOUR OWN LIGHT CLIENT?**
> You can check out [our docs here](/docs/da/operate/run-a-light-client/light-client#running-the-light-client) for instructions on how to run your own light client.
> **Warning**
>
> **Note:**
> Light client must be running in `app-mode`to retrieve data. [Click here](/docs/da/operate/run-a-light-client/light-client#setting-your-identity-using-identitytoml) for instructions on how to run an Avail Light Client in `app-mode`.
> Submits application data to the avail network
In case of `data` transaction, data transaction is created, signed and submitted.\
In case of `extrinsic`, externally created and signed transaction is submitted.
Only one field is allowed per request.\
Both `data` and `extrinsic` has to be encoded using base64 encoding.
*Params:*
* `base64` encoded data or extrinsic
> **Note**
>
> **HOW TO SUBMIT DATA USING THE LIGHT CLIENT?**
>
> 1. To use this method you need to run your Light Client in the `app-client` mode.
> You can then submit data directly to the `appID` you configured while booting up the Light Client.
>
> 2. You can only pass `Base64` encoded data to be submitted via the Light Client.
> You can use [this website](https://www.base64encode.org/) to encode & decode your data into the required formats.
*Response:*
* **block\_number** - block number where transaction is included
* **block\_hash** - block hash where transaction is included
* **hash** - transaction hash
* **index** - transaction index in the block
#### CURL
```bash filename="CURL"
curl -XPOST 127.0.0.1:7007/v2/submit --header "Content-Type: application/json" --data '{"data":"dGVzdAo="}'
```
#### Rust
```rust
use reqwest::{Client, StatusCode};
use serde::{Deserialize, Serialize};
use serde_json::json;
#[derive(Debug, Serialize, Deserialize)]
struct SubmitResponse {
block_number: u32,
block_hash: String,
hash: String,
index: u32,
}
const LIGHT_CLIENT_URL: &str = "https://api.lightclient.mainnet.avail.so";
#[tokio::main]
async fn main() {
let client = Client::new();
let submit_url = format!("{LIGHT_CLIENT_URL}/v2/submit");
let data = "dGVzdAo="; // Example base64 encoded data
let response = client.post(&submit_url)
.header("Content-Type", "application/json")
.body(json!({ "data": data }).to_string())
.send()
.await
.unwrap();
match response.status() {
StatusCode::OK => {
let submit_response: SubmitResponse = response.json().await.unwrap();
println!("Submit response: {:?}", submit_response);
}
StatusCode::NOT_FOUND => {
println!("App mode not active or signing key not configured.");
}
_ => {
eprintln!("Failed to submit data: {}", response.status());
}
}
// ...error handling...
}
```
> If you choose to create a new `AppID`, it's `id` will be the next integer in the sequence.
## How to register my own `AppID`?
1. You need to connect an Avail DA account to the website. Click on `Connect wallet` to do so.
> **Note**
>
> If you don't have an Avail DA wallet, you can follow our docs on [setting up a new wallet](/docs/da/user-guides/accounts#creating-an-account-on-avail-da).
2. Once connected, simply give your `AppID` a name, click on `Create AppID` and approve the transaction in your wallet to create the `AppID`.
## A few more things of note
1. As stated earlier, the `key` and `id` fields of every `AppID` are unique. This means if you try to create an `AppID` with the same `key` as an existing one,
the operation will fail.
2. If you're a developer and are looking for more programmatic instructions, you can check out our [API reference](/docs/da/api-reference/avail-node-api/da-create-application-key).
### Testnet Faucet
The Avail testnet faucet will be living at [faucet.avail.tools](https://faucet.avail.tools/) for the foreseeable future.
As of now, this is the only officially supported faucet for Avail DA.
> **Note**
>
> PLEASE NOTE
> The faucet is designed to distribute small amounts of AVAIL for testing purposes, not large quantities for validator bonding or similar activities.
> The current maximum balance a requesting address can have is 100 AVAIL.
## How to Use the Faucet
1. Create a Substrate account using a compatible wallet.
We recommend [SubWallet](https://www.subwallet.app/), [Talisman](https://www.talisman.xyz/), or [PolkadotJS](https://polkadot.js.org/).
2. Go to [faucet.avail.tools](https://faucet.avail.tools/).
Chains built with the Avail OP Stack inherit the security guarantees of Avail’s nominated proof-of-stake blockchain network.
Get started with building your Avail-powered OP Stack chain today.
- [**Transaction Lifecycle**](/docs/da/build/rollups/op-stack/overview)
- [**Avail-Powered Optimium (OP Stack)**](/docs/da/build/rollups/op-stack/guide)
- [**OP Stack Adapter**](https://github.com/availproject/avail-op-stack-adapter)
### Polygon zkEVM
- [**Overview**](/docs/da/build/rollups/zkevm/overview)
- [**Avail-Powered zkEVM Validium**](/docs/da/build/rollups/zkevm/guide)
- [**Validium Node**](https://github.com/availproject/validium-node)
- [**Validium Contracts**](https://github.com/availproject/validium-contracts)
- [**Validium Bridge**](https://github.com/availproject/validium-bridge-service)
### How to Run an Avail node
## How to run an Avail node
There are four main ways of running an Avail node:
1. By running a pre-built binary.
2. By building from source
3. By running a pre-built image using Docker
4. By assisted deployment with an infrastructure provider
> **Note**
>
> **LOOKING TO BE AN RPC PROVIDER?**
>
> We welcome all community members who are looking to run an RPC node on Avail.
> While the exact config of your node will depend on your unique requirements, the following flags are
> required to make sure your node can be used to access all RPC methods:
>
> ```bash showLineNumbers filename="avail-node flags"
> --state-pruning archive
> --blocks-pruning archive
> --rpc-methods Safe
> --rpc-cors all
> --unsafe-rpc-external
> --enable-kate-rpc
> ```
>
> 
### Avail Node - Simple Deployment
## Introduction
> **Note**
>
> **ASSISTED DEPLOYMENT**
> If you prefer running your Avail validator with the help of an infrastructure provider, you can check out [on-finality's docs here](https://documentation.onfinality.io/support/set-up-an-avail-validator-with-onfinality).
This guide aims to help you learn the basics of deploying your Avail Node manually or by docker/podman.
## Cloud Server
Deploying long-lasting services is best done on an online machine more than 99% of the time and is dedicated solely to running that service. This means that your Avail Node should not be deployed on a personal computer; running it on your Homelab or a cloud provider is a better option.
There are many cloud providers to choose from. Here are some of them:
* AWS
* Microsoft Azure
* OVHCloud
* DigitalOcean
* Linode
* Google Cloud Platform
It's up to you to research and pick one that will suit all your needs and requirements.
If you already have a running server, you can skip the rest of this section and go straight to the next one.
That said, Latitude is used for this chapter and here are the steps on how to create a new instance there:
1. First, create a project and give it a name.
2. Click on the 'Create Server' button and choose your desired location and image.
3. Click on the 'Create Server' button and choose your desired location and image. We're using Ubuntu 24 for this guide.
4. For the server type, `c2.small.x86` , `s2.small.x86` , `c2.medium.x86` or anything stronger should do the trick.
5. Enter your SSH keys
6. Give your server a name.
7. Copy the IP and SSH of your server.
8. SSH into your server by running the following command in your terminal:
```bash
# Replace the IP with your own
ssh ubuntu@199.xxx.xxx.xxx
```
9. If everything is set up correctly, you should see the welcome message:
## Bare Metal
We have our server up and online. We updated all our dependencies and are ready to do the work.
> **Note**
>
> **BEFORE WE BEGIN**
>
> While working with Linux distros, it is a good practice to update the package list and upgrade the system before undertaking
> major operations. You can use this command to do so:
>
> ```bash
> sudo apt update && sudo apt upgrade -y
> ```
1. Let's create a folder in the home directory to store our binary and all the data it will generate.
```bash
mkdir avail && cd avail
mkdir node-data
```
2. Depending on the user and operating system used, the path to our newly created folder can be `/root/avail` or `/home/ubuntu/avail` or any other variant. To get the full path, run this:"
```bash
pwd
# Example output: `/root/avail`
```
3. From the [Releases Page](https://github.com/availproject/avail/releases), we grab the latest version and unpack it.
> **Warning**
>
> NODE VERSION FOR TURING
> Please note that the Avail node underwent major breaking changes while making upgrades to transition towards Turing.
```bash
# Obtaning Latest avail-node version for Ubuntu 22.04
# Put in the latest version in the command below
# wget is a command-line utility for downloading files from the internet.
wget https://github.com/availproject/avail/releases/download/
Avail telemetry has been added to the chain specification file and should automatically send telemetry data to Avail [public telemetry](http://telemetry.avail.so/). You can however also
add the telemetry `--telemetry-url 'ws://telemetry.avail.so:8001/submit/ 0'` to your avail node start command if your node is not visible on the public telemetry.
You can also use `--name 
You will be asked to reset your password, please write it down or remember the password as you will need it for the next login.
You will need to create a datasource. Navigate to **Home->Connections->Data sources**
Click on **Add data source**
Click on **Prometheus**
Set URL to "localhost:9090", then test and save the connection
Navigate back to your home page, on the top right in the menu select **Import dashboard**
Import the [Avail Node Metrics file](https://raw.githubusercontent.com/availproject/docs/main/static/validator_metrics.json)
You will have a new dashboard that opens and that you can use to monitor your node
### Avail Node - Session Keys
## Introduction
> **Note**
>
> BEFORE YOU START
> This chapter continues from the 'Simple Deployment' page, so be sure to read that one before proceeding with this one.
> **Note**
>
> NOTE
> Before trying anything, make sure that you fully read the chapter first before doing any actual work.
With our infrastructure set up and our node running, we are ready to register ourselves as potential future validators. If the need for on-chain registration to become a validator seems foreign to you, then this would be a perfect opportunity to do your own research about how Proof of Stake and Nominated Proof Of Stake works.
In short, to prevent people from running faulty validators and earning tokens, all validators need to bond a certain amount of tokens to register and be eligible for the position of producing blocks. With that mechanism in place, all validators that are in some way faulty will either be deregistered or, in the worst case, slashed.
This explanation only covers the surface of how the whole system works, and before continuing, make sure that you do your own research and learn how the system actually operates. A good place to start is to read [Polkadot's explanation](https://wiki.polkadot.network/docs/learn-staking) on how it works.
## Session Keys
Before we can bond our tokens we need to generate our session keys.
In simpler terms, session keys in Substrate are like special secret codes that uniquely identify who's in charge of creating and validating blocks in a blockchain. Each participant, known as a validator, has their own secret key. They use these keys to sign off on the blocks they create, sort of like a personalized signature. This helps make sure everyone knows who's responsible for what, and it adds a layer of security to the whole blockchain process. So, we can think of session keys as the blockchain's way of keeping track of who did what in a trustworthy and secure manner.
To generate it, we can the following command inside the server that is running our node:
### Bare Metal:
```bash
# Generate session keys
curl -H "Content-Type: application/json" -d '{"id":1, "jsonrpc":"2.0", "method": "author_rotateKeys", "params":[]}' http://localhost:9944
# Restart our Node
sudo systemctl restart avail.service
```
### Docker/ Podman
```bash
# First let's ssh into our container
# Option 1: Docker non-root
sudo docker exec -it $(docker ps -lq) /bin/bash
# Option 2: Podman
podman exec -lit /bin/bash
# Generate the Session keys
curl -H "Content-Type: application/json" -d '{"id":1, "jsonrpc":"2.0", "method": "author_rotateKeys", "params":[]}' http://localhost:9944
# Exit and restart containe
exit
# Option 1: Docker non-root
sudo docker restart $(docker ps -lq)
# Option 2: Podman
podman restart -l
```
> **Note**
>
> NOTE
> If you encounter the following error inside the container: `bash: curl: command not found`, make sure to first install `curl` inside the container and then retry it.
> For Ubuntu, you can run `apt install curl -y` for root or `sudo apt install curl -y` for non-root user to have it installed
### Output
Running the curl command either bare metal or inside a container should yield the same result. The command generated the session keys for us, stored them inside our node-related-data folder, and displayed it for us. This key is unique to your own node, so it's important to make sure that it is stored safely and never shared with anyone.
Example Output
```json
{
"jsonrpc": "2.0",
"result": "0x0c26b9ba4b8fb5f3051a24663ce491663d8e8e81e8f1450ab23e4edd7d3b4f4c7e5e1047ae1edAb5bde2dad7915629b8aec892c550515ed0b1cb7e056e8a33d16c9c7faba50abd75438d4a2bbdbb6b2c35e09ad480e07ffeb1a2175feda23a3fd475eb0ad21e2f67693a1d6964b81d1454a19dd53256223a178a74cb0df4cc43",
"id": 1
}
```
### How to Stake Your Validator
This guide offers a step-by-step walkthrough on how to stake your Avail validator.
It covers essential steps such as bonding your funds, managing session keys, and initiating the validation process.
> **Note**
>
> BEFORE YOU START
> This chapter continues from the 'Session Keys' page, so be sure to read that one before proceeding with this one.
## Step 1: Prepare for Staking
Before you can become an active validator, you need to bond your funds to your node. This involves creating two separate Avail accounts: a `stash` account for holding your funds and a `controller` account for managing staking actions.
### Create Avail Accounts
1. Navigate to the Avail network explorer at [https://explorer.availproject.org/](https://explorer.availproject.org/) and choose the correct network.
2. Create a `stash` account.
### Bond Your Funds
> **Note**
>
> BONDING TIPS
> Don't bond all your AVAIL tokens as you'll need some for transaction fees. You can always bond more tokens later.
> Note: Withdrawing any bonded amount is subject to the duration of the unbonding period.
1. Navigate to the **Staking** tab in the Explorer.
2. Click on `Stash` to initiate the bonding process.
3. Fill in the bonding preferences. Then click `Bond` and `Sign and Submit`.
> **Warning**
>
> You need at least 50,000 AVAIL to join waiting list.
## Step 2: Manage Session Keys
After your node is fully synced, you'll need to rotate and submit your session keys.
### Rotating Session Keys
Run the following command on your node machine:
> Ensure the node is running with the default HTTP RPC port configured.
#### Using Binaries:
```shell
curl -H "Content-Type: application/json" -d '{"id":1, "jsonrpc":"2.0", "method": "author_rotateKeys", "params":[]}' http://localhost:9944
```
The result is the concatenation of the four public keys. Save the hex-encoded
result for the next step and **restart your node**.
#### Using Docker:
```shell
docker ps
```
You should an output similar to:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
da097bbeba75 availj/avail:v1.8.0.4 "/entrypoint.sh" 3 seconds ago Up 3 seconds 0.0.0.0:9615->9615/tcp, :::9615->9615/tcp, 0.0.0.0:9944->9944/tcp, 0.0.0.0:30333->30333/tcp, :::9944->9944/tcp musing_cartwright
```
We need the `CONTAINER ID` from the output above:
```shell
docker exec -i da097bbeba75 curl -sH "Content-Type: application/json" -d '{"id":1, "jsonrpc":"2.0", "method": "author_rotateKeys", "params":[]}' http://localhost:9944
```
### Submit Session Keys
You must inform the network of your Session keys by signing and submitting the
`setKeys` extrinsic. This action associates your validator with your Controller account.
1. Navigate back to the **[Staking](https://explorer.availproject.org/#/staking/actions)** tab.
2. Click on `Set Session Key` and enter the hex-encoded result.
3. Click `Set Session Key` and enter your password when prompted.
After submitting the extrinsic, you'll observe that **Set Session Key** changes
to **Validate**. Make sure your node is fully synchronized before proceeding further.
## Step 3: Register as a Validator
1. Click `Validate` on the **Staking** tab.
2. Set your validator commission percentage.
3. Enter your password and click `Validate`.
## Step 4: Start Validation
Your validator is now prepared to begin the validation process. If you wish to discontinue,
you can click the stop icon. Please note that the Avail interface doesn't automatically verify
if your node is synchronized; you'll need to confirm this manually. If your node has sufficient
stake, the Avail blockchain will likely select it in the next epoch or two.
### Verify Validator Status
To verify that your node is ready for possible selection at the end of
the next era, follow these steps:
1. Go to the **[Staking](https://explorer.availproject.org/#/staking)** tab and
select `Waiting` to see if your account appears.
2. If your node has enough stake, it will be elected in the next era or two.
> A new set of validators is chosen every **era**, based on the amount staked.
### Monitor Validator in Action
Once your validator node has accrued enough stake, it will be elected for validation.
Below is an example image of an elected validator node actively producing blocks.
In addition, please check out the guide on validator monitoring available
[here](/docs/da/operate/become-a-validator/monitor-your-validator).
## Next Steps
Congratulations on successfully setting up your Avail Validator node!
You should be seeing something like this:
As you move forward, here are some essential actions to consider:
1. **Backup Your Validator**: Ensure you have a secure backup of your validator settings and keys. Refer to the
[Backup Guide](/docs/da/operate/become-a-validator/backup-your-validator) for detailed steps.
2. **Start Monitoring**: If you haven't already, set up monitoring tools to keep track of your validator's performance. Check out the [Monitoring Guide](/docs/da/operate/become-a-validator/monitor-your-validator) for recommendations.
3. **Join the Community**: Connect with other validators and the Avail team on the official [Discord Channel](https://discord.com/invite/AvailProject). It's a great place to share experiences, ask questions, and get updates.
### How to Run an Avail light client
> **Note**
>
> **LOOKING FOR THE LIGHT CLIENT API REFERENCE?**
> Go to [light client API reference](/docs/da/api-reference/avail-lc-api)
1. Use [Availup](https://github.com/availproject/availup) to run the light client.
2. Download and run a pre-built binary.
3. Build your Light client from source
## Latest release
You can find the latest release binary in the [`avail-light`](https://github.com/availproject/avail-light) repository.
> **Note**
>
> **RECOMMENDED VERSION**
> You can find the latest release of the Avail LC from [our Github repo](https://github.com/availproject/avail-light).
> We recommend devs to use the `Latest` release.
## Light client modes
The Avail light client has two main modes of operation:
1. **Light-client mode**: The basic mode of operation and is always active no matter the mode selected.
If an `app_id` is not provided (or is = 0), this mode will commence. On each header received the client
does random sampling using two mechanisms
2. **App-client mode**: If an `app_id > 0` is given, the application client
(part of the light client) downloads all data specific to that App ID, reconstructs it and persists it locally.
This data can then be accessed via a local HTTP endpoint.
> **Note**
>
> **WE RECOMMEND LEARNING ABOUT APP IDs on AVAIL DA**
> App IDs are an important concept in the context of Avail. We recommend you go through [this page in our docs](/docs/da/concepts/app-ids) to understand how they work before moving forward.
## Running the light client
#### Light-client mode
> **Note**
>
> **CONFIG FLAGS**
> Availup supports many different config flags to support your needs.
> Detailed documentation for them can be found [in our Github repo](https://github.com/availproject/availup?tab=readme-ov-file#availup).
**[`availup`](https://github.com/availproject/availup)** is the recommended way of running the Avail light client for most users.
`availup` is a shell wrapper that allows you to spin up your own instance of the Avail light client
with a simple `curl` command.
> **Note**
>
> To run the Avail LC using `availup`, make sure you have [`curl`](https://curl.se/) installed on your system. To check, quickly:
>
> ```sh
> curl --version
> ```
1. To spin up an Avail light client on the Turing testnet, just run this one command in your terminal:
```sh
curl -sL1 avail.sh | bash
```
2. If everything goes well, the client output will look like this:
> **Note**
>
> Please note this command worked for a system where the `identity.toml` file was in the same directory as the terminal.
> You will need to pass the full path to the `identity.toml` file if it is located elsewhere.
#### Run pre-built binary
> **Note**
>
> **CONFIG FLAGS**
> You can run the Avail light client with different flags to configure it according to your needs.
> Detailed documentation for them can be found [in our Github repo](https://github.com/availproject/avail-light/blob/main/client/README.md#options).
You can also download and run a pre-built binary of the Avail light client.
To do so:
1. Download the [recommended version of the binary](https://github.com/availproject/avail-light/releases) that is compatible with your operating system.
2. Move the `.tar` file into a convenient directory and extract it to reveal the `avail-light` binary.
3. Open a terminal in that location and run:
For linux machines that run on `x86_64` based Intel or `amd64` based AMD processors, run:
```sh
./avail-light-linux-amd64 --app-id 18 --network mainnet --identity identity.toml
```
#### Build from source
For linux machines that run on `arm64` based processors, run:
```sh
./avail-light-linux-arm64 --app-id 18 --network mainnet --identity identity.toml
```
#### apple-x86_64
For MacOS machines that run on `x86_64` based Intel processors, run:
```sh
./avail-light-apple-x86_64 --app-id 18 --network mainnet --identity identity.toml
```
#### apple-arm64
For MacOS machines that run on newer `arm64` based M-series processors, run:
```sh
./avail-light-apple-arm64 --app-id 18 --network mainnet --identity identity.toml
```
> **Note**
>
> You can configure the run command with a variety of [config flags](https://github.com/availproject/avail-light/blob/main/client/README.md#options).
> **Note**
>
> **CONFIG FLAGS**
> You can run the Avail light client with different flags to configure it according to your needs.
> Detailed documentation for them can be found [in our Github repo](https://github.com/availproject/avail-light/blob/main/client/README.md#options).
Building the Avail light client from source is a more advanced option that
provides you with the maximum flexibility.
To do so:
1. Clone the Avail light-client repo and checkout to the specified version:
```sh
git clone https://github.com/availproject/avail-light.git
cd avail-light
```
2. Make sure your terminal is in the `avail-light` directory. Create a compiled build by running:
```sh
cargo build --release
```
3. This will create a new directory named `target` within `avail-light`. Navigate to `target/release` using:
```sh
cd target/release
```
4. Here you will find the `avail-light` build. Run the build using:
```sh
./avail-light --app-id 18 --network mainnet --identity identity.toml
```
### How to Upgrade Your Avail Validator
When upgrading Avail nodes there are two options, a faster method and a slower (but safer) method. Both are detailed below, but you only need to use one of them.
## Fast Upgrade
While a rapid upgrade is possible, it carries inherent risks if done on a validator node. For instance, if you proceed with the upgrade on a validator node and encounter issues such as database corruption, there's a chance of prolonged downtime. This could lead to your node being removed from the active validator set due to unresponsiveness.
This upgrade process is appropriate for non-validator nodes. However, this upgrade process is still possible on validator nodes with careful consideration.
The fast upgrade steps are:
* Stop the Avail node.
```
sudo systemctl stop avail.service
```
* Locate your Avail binary, create a backup of the current binary, and then uninstall the existing binary by deleting the binary. Proceed to download the most recent binary announced in Discord, which will replace the previous binary version.
To provide an example, assuming your existing binary is located at `/home/avail/avail-node/` and is named `data-avail`, and you used the [validator](/docs/da/operate/become-a-validator) setup guidelines while obtaining a pre-built binary from the Avail GitHub repository, proceed as outlined below.
```
cd /home/avail/avail-node/
mv data-avail data-avail-backup
wget https://github.com/availproject/avail/releases/download/v1.10.0.0/x86_64-ubuntu-2004-data-avail.tar.gz
tar -xvf data-avail-linux-amd64.tar.gz
mv data-avail-linux-amd64 data-avail
rm data-avail-linux-amd64.tar.gz
```
* Start the Avail node again.
```
sudo systemctl start avail.service
```
* Ensure your node starts syncing with the network, view the logs from the running service.
```
journalctl -f -u avail.service
```
* Also check that your node is visible on telemetry and the version matches the upgrade version.
## Slow & Safe Upgrade
This upgrade procedure is most appropriate for validator nodes exclusively and is unnecessary for other types of nodes, such as full, archive, rpc, and so forth. Upgrading a Avail node safely is a careful process to ensure a smooth transition without disruption to the network. Here's a step-by-step guide on how to upgrade a Avail node,
including the process of switching nodes using rotated keys:
* Preparing for the Upgrade:
* Ensure you have a backup of your node's data and keystore files. This ensures you can restore your node in case of any issues during the upgrade process.
Familiarize yourself with the release notes and documentation of the new Avail version to understand any specific instructions or requirements.
* Setting up Node B:
* Install and set up the new version of Avail on a separate server or machine. This will be Node B, which will eventually replace Node A. Configure Node B with the
necessary configuration files, including the customizations you had on Node A. Ensure that Node B is fully synchronized with the Avail network before proceeding.
* Generating Rotated Keys:
* Generate a new set of keys for Node B using `author_rotateKeys`.
* Updating Session Keys:
* Open Avail Apps and navigate to [Network → Staking](https://testnet.avail.tools/#/staking/actions). You will be able to select from a hidden menu the option
to change session keys.
* Can enter the hex-encoded value obtained from `author_rotateKeys` and click on **Set Session Key**.
* You will now be able to see the new and old hex-encoded value. In the next epoch or two it will only show the new hex-encoded
value.
* After a few epochs Node B will be performing the validator tasks. You must ensure this by looking in the logs for sealed blocks. You should see `🎁 Prepared block for proposing` appear
in the logs of Node B and stop appearing Node A.
* You can now upgrade Node A. You can repeat the process to switch back to Node A.
> **Warning**
>
> ENSURE THE NODE HAS SWITCHED
> Before turning Node A off you must ensure Node B has become the active validator. In Avail Apps it may show the switch, however there is an epoch delay before the node
> fully switches over. The best is to look in the logs and confirm the new node is sealing the blocks.
### The Light Client Lift-off challenge
> **Warning**
>
> The Avail LC challenge has now ended. Please note that no member of the Avail team will personally reach out
> **to ask you for any personal information or payment**. Rewards for the challenge can only be claimed from the official
> claims page. In case of any queries, you can join our Discord server.
### Introduction to Avail light clients
## System Requirements
This is the hardware configuration required to set up an Avail light client:
| Component | Minimum | Recommended |
| ---------------------------- | :-----: | :---------: |
| RAM | 512MB | 1 GB |
| CPU (amd64/x86 architecture) | 2 core | 4 core |
{/* | Storage (SSD) | 20-40 GB | 200-300 GB | */}
> **Note**
>
> **JUST LOOKING FOR INSTRUCTIONS?**
> If you're not interested in theory, skip [to this link](/docs/da/operate/run-a-light-client/light-client) for instructions on how to run an Avail light client.
## Introduction
Avail light client (LC) lets you interact with Avail DA without requiring a full node and without trust assumptions towards remote peers.
This is accomplished by leveraging **Data Availability Sampling (DAS)** performed by the light client on every newly created block.
The light client listens on the Avail network for finalized blocks and performs DAS on a predetermined number of cells on each new block.
After successful block verification, **block confidence** is calculated for a number of cells in the matrix, with the number depending on the percentage of certainty the users wishes to achieve.
### Review your transaction details
Click on the `Initiate` button to start the bridging process.
### Now, wait!
Bridging AVAIL from Avail DA to Ethereum typically takes 1-2 hours.
You can check the `Transactions` tab in the UI to see the status of your transaction.
Wait for the transaction status to change to `Claim Ready`.
### Claim your funds
You will need to manually claim `AVAIL` on Ethereum with the same EVM address you connected earlier. used in `step 1`.
Click on `Claim Ready` and approve the transaction in your wallet.
Your AVAIL tokens on Ethereum mainnet will then be transferred to your account.
> **Note**
>
> Please note that you are executing a transaction on Ethereum in this step, so you will need to have some ETH in your wallet to pay for the gas fees.
> **Note**
>
> This exact process can be reversed to bridge AVAIL from Ethereum to Avail DA.
#### Using a Ledger device
### Make sure you have a Ledger device ready
If you need instructions on how to get started with a ledger device, please refer to our docs.
1. [Set up a new ledger device](/docs/da/user-guides/ledger-avail#set-up-your-ledger-from-scratch)
2. [Connect a ledger account to your Subwallet/Talisman extension wallet](/docs/da/user-guides/ledger-avail#add-your-ledger-account-to-an-extension-wallet)
### Click on the `Connect` button in the Bridge ui & select your preferred wallet
### Select your ledger account from within your wallet
> **Note**
>
> 1. Please note that you need to have the `Avail` app installed on your ledger device.
> 2. Your ledger device needs to be unlocked during the entire process.
### Connect the selected ledger account to the bridge UI
### Fill out the rest of the details and click on `Approve`
1. Specify the amount of AVAIL you want to bridge.
2. Specify the destination address on the other chain, or simply connect an EVM wallet to the bridge UI.
3. Initiate the bridging process.
4. Click on `Approve` in the pop-up window. This will send the transaction to your ledger device.
### Approve the bridging transaction on your ledger device
1. Unlock your ledger device.
2. Approve the bridging transaction on your ledger device.
3. Wait for a while, and you should see a transaction confirmation message in the bridge UI.
### Bridge between Ethereum & Base
## Using the Bridge
> **Warning**
>
> **CHOOSE NETWORKS CAREFULLY**
> The bridge UI defaults to a `Avail → Ethereum` network combination. \
> Choose your networks carefully.
### Go to the official `avail-bridge` UI & select the networks you want to bridge between
1. Go to [bridge.availproject.org](https://bridge.availproject.org/).
2. Select the source chain as `Ethereum`
3. Select the destination chain as `Base`
4. Or vice-versa, if you want to bridge from Base to Ethereum.
### Connect your wallets
1. Connect your Ethereum EVM wallet.
2. Connect your Base EVM wallet.
### Enter transaction details
1. Enter the amount you want to bridge.
2. Click on the `Review` button to review your transaction details.
### Initiate the bridging process
1. Click on the `Initiate` button to start the bridging process.
2. Approve the two signatures that pop up.
> **Note**
>
> This exact process can be reversed to bridge AVAIL from Base to Ethereum.
### Bridge between Avail & Base
## Video guide
If Youtube is more your style, you can watch the video guide below,
or else you can just refer to the written guide below this section.
## Using the Bridge
> **Warning**
>
> **CHOOSE NETWORKS CAREFULLY**
> The bridge UI defaults to a `Avail → Ethereum` network combination. \
> Choose your networks carefully.
### Go to the official `avail-bridge` UI & select the networks you want to bridge between
1. Go to [bridge.availproject.org](https://bridge.availproject.org/).
2. Select the source chain as `Avail`
3. Select the destination chain as `Base`
4. Or vice-versa, if you want to bridge from Base to Avail.
### Connect your wallets
1. Connect your Avail wallet.
2. Connect your Base EVM wallet.
### Enter transaction details
1. Enter the amount you want to bridge.
2. Click on the `Review` button to review your transaction details.
### Initiate the bridging process
1. Click on the `Initiate` button to start the bridging process.
2. Approve the two signatures that pop up.
> **Note**
>
> This exact process can be reversed to bridge AVAIL from Base to Avail.
### Proxy Accounts on Avail DA
Proxy accounts provide an efficient way to delegate account management while maintaining security.
Instead of using a single account for all operations, you can create smaller accounts with specific roles
that can act on behalf of your main account. This guide explains how proxy accounts work on Avail DA and
how to use them through an example.
## What are Proxy Accounts?
Proxy accounts allow you to:
* Delegate specific permissions to other accounts
* Keep your main account secure while still participating in network activities
* Manage accounts efficiently, especially in corporate or team settings
> **Note**
>
> Think of proxy accounts as trusted delegates that can perform specific actions on behalf of your main account. The main account stays secure in cold storage while proxy accounts handle day-to-day operations.
## Proxy Types
When setting up a proxy account, you must specify its type. This determines what actions the proxy can perform:
* **Any**: Allows all transactions, including balance transfers. Use with caution as this gives complete control.
* **Non-transfer**: Permits any transaction except balance transfers.
* **Governance**: Only allows governance-related transactions.
* **Staking**: Restricted to staking-related operations.
* **Identity**: Restricted to identity registration and management operations.
* **Nomination Pool**: Limited to nomination pool operations like joining, bonding, and claiming rewards.
## Security Features
### Proxy Deposits
Creating a proxy requires a deposit in AVAIL tokens. This deposit is:
* Required to prevent spam attacks
* Calculated based on the formula: `ProxyDepositBase + (ProxyDepositFactor * number_of_proxies)`
* Returned when the proxy is removed
> Currently:
>
> * `ProxyDepositBase` is 10 AVAIL
> * `ProxyDepositFactor` is 3 AVAIL
## Setting up a Proxy Account
### Go to the Explorer
Head on over to the [accounts section of the Avail explorer](https://explorer.availproject.org/#/accounts) and connect your main account.
### Click on *'Add proxy'*
1. Choose the account for which you want to add a proxy.
2. Click on the *'Add proxy'* button to get started.
> **Warning**
>
> **Thank you for participating in Avail's Unification Drop.**
> Note that all phases of the unification drop have been completed, and the **official claims portal
> is now closed.**
> Please beware of any phishing or scam attempts. Only rely on official Avail communication channels for information.
### $AVAIL in Avail DA
* Validators stake AVAIL to participate in block production and provide data availability guarantees.
* Misbehaviour may result in slashing, enforcing economic accountability.
* Applications integrated with Avail DA pay fees in AVAIL to publish data.
### $AVAIL in Avail Nexus
* Users express cross-chain intents such as deposits, swaps, or transactions. The protocol coordinates their execution across chains.
* Activity on Nexus generates protocol revenue. Protocol revenue may be used for AVAIL buybacks in accordance with network governance and policy.
* Avail Nexus relies on Avail DA in the backend, increasing demand for data publication and blockspace on the network.
## Staking with AVAIL
Anyone can stake AVAIL throughout Avail's infrastructure to earn staking rewards. We will release detailed staking guides
along with our products as they are released.
For now you can refer to the Avail DA staking guide [in our docs](/docs/da/user-guides/staking-governance/stake-on-avail).
If you want to read about staking on Avail in more detail, you can refer to [our blog](https://blog.availproject.org/avail-the-token-powering-blockchain-unification/#avail-staking).
## Governance with AVAIL
The AVAIL token will play a key role in governance throughout the Avail ecosystem.
Avail will be adopting a phased approach to governance.
More information will be published on this soon.
## Security update
Notice:
Effective January 20, 2025, locked tokens will be redistributed from a single account to multiple secure accounts to enhance operational security.
This strategic measure aims to strengthen the security of foundation-held assets by reducing concentration risk.
The foundation remains committed to improving operational security while maintaining transparency.
There are no changes to the fundamental tokenomics, and distribution parameters will remain exactly as outlined in the existing documentation.
### Stake on Avail
- [**Overview**](/docs/da/user-guides/staking-governance/stake-on-avail/overview)
- [**Direct Nomination**](/docs/da/user-guides/staking-governance/stake-on-avail/direct-nomination)
- [**Nomination Pools**](/docs/da/user-guides/staking-governance/stake-on-avail/nomination-pools)
### Deploy a Polygon cdk Validium with Avail DA
## Introduction
In this guide, we will walk you through the process of deploying a Polygon CDK Validium chain using Avail as the data availability layer. This setup allows you to leverage the scalability and security of Avail for your rollup.
By following this guide, you will learn how to launch a CDK chain on Local or Sepolia testnet, configure it to use Avail for data availability, and interact with your rollup.
* [Learn more about Polygon CDK](https://docs.polygon.technology/cdk/getting-started/local-deployment/)
In this guide, we will cover:
* [Deploying CDK with AvailDA on local](#deploying-cdk-with-availda-on-local)
* [Deploying CDK with AvailDA on Sepolia](#deploying-cdk-with-availda-on-sepolia)
## Prerequisites:
* CPU: 4 CPUs, amd64
* Memory: 32 GB
* Storage: 100 GB
* OS: Linux
| Software | Version |
| ------------------------------------------------------------------ | ---------- |
| [Git](https://git-scm.com/) | OS Default |
| [Docker](https://www.docker.com/) | Latest |
| [Docker Compose](https://docs.docker.com/compose/) | Latest |
| [Kurtosis](https://docs.kurtosis.com/install/) | Latest |
| [GO](https://go.dev/doc/install) | Latest |
| [Make](https://www.gnu.org/software/make/) | OS Default |
| [Polygon-cli](https://github.com/0xPolygon/polygon-cli) | Latest |
| [Foundry](https://book.getfoundry.sh/getting-started/installation) | Latest |
After executing the following commands you will have installed all the prerequisites needed.
## Deploying CDK with AvailDA on Local
### 1. Build CDK image
[CDK](https://github.com/availproject/cdk) is a modular framework to build and deploy ZKP enabled rollups and validiums. This framework allows you to build a rollup or validium chain with a few simple commands, which is verifiable using zkEVM prover from Polygon.
```bash
git clone https://github.com/availproject/cdk.git
cd cdk
git checkout avail-develop-v0.5.3-rc1
make build-docker
docker tag cdk availproject/cdk:avail-develop-v0.5.3-rc1
```
### 2. Build [cdk-zkevm-contracts](https://github.com/availproject/cdk-zkevm-contracts) image with mock AvailDABridge and proof verification
```bash
git clone https://github.com/availproject/kurtosis-cdk.git
cd kurtosis-cdk/docker
git checkout avail-develop-v0.3.4
docker build . \
--tag availproject/cdk-zkevm-contracts:avail-develop-v9.0.0-rc.6-pp-fork.12 \
--build-arg ZKEVM_CONTRACTS_BRANCH=mock-bridge-avail-develop-v9.0.0-rc.6-pp \
--build-arg POLYCLI_VERSION="v0.1.73" \
--build-arg FOUNDRY_VERSION=stable \
--file zkevm-contracts.Dockerfile
```
### 3. Add AvailDA config values in `cdk-node-config.toml`
```bash
cd kurtosis-cdk/templates/trusted-node
vim cdk-node-config.toml
```
Enter your `Seed Phrase` and `appID`. Other information are prefilled for you.
### 4. Run local CDK chain with AvailDA using Kurtosis-cdk
```bash
cd kurtosis-cdk
kurtosis run --enclave cdk .
```
This command will start a local CDK chain with Avail as the data availability layer. It will take a few minutes to initialize the chain and all the services.
### 5. Chain is up and running
Now you should have a local CDK chain with AvailDA up and running. Try interacting with it as defined in these [docs](https://docs.polygon.technology/cdk/getting-started/local-deployment/#interacting-with-the-chain).
Some useful examples to interact with the chain can be Read/write opertations.
1. First export the RPC URL of your L2 to an environment variable called `ETH_RPC_URL`:
```bash
export ETH_RPC_URL="$(kurtosis port print cdk cdk-erigon-sequencer-001 rpc)"
```
2. Use `cast` to view information about the chain:
```bash
cast block-number
```
3. To View the balance of a pre-funded admin account:
```bash
cast balance --ether 0xE34aaF64b29273B7D567FCFc40544c014EEe9970
```
To check Avail Logs of `cdk-node-001`, use `kurtosis service logs -f 
### (Optional) Click on the `Validators` tab in the left sidebar to evaluate validators on the network
You can click on the `Validators` tab in the left sidebar to view a list of validators currently
active on Avail DA.
The dashboard allows you to filter out validators based on a number of criteria so you can make an informed choice.
Once you have selected you may click on `+Next` button.
### Click on the `Nominate` tab in the left sidebar
This is how the nominate page in the staking dashboard looks like, once you have connected a wallet.
You can also connect multiple addresses to this page, and ctycle between them using the `Accounts` button.
### Click on the `Start Nominating` button
Now you will see a few different options to configure your nominating experience to your liking.
Lets go through them one by one.
### Select your Payout preferences.
You have three main options here:
* **Compound**: This will automatically re-stake your rewards as they come.
* **To Your Account**: This will send your rewards to the account you used to stake.
* **To Another Account**: This will send your rewards to a different account you specify.
Select one of these options and click on `Continue`.
### Choose your validators
You have three main options here:
* **Optimal selection**: Allow the dashboard to simplify the whole process and
fetch a list of upto 16 validators for you to nominate.
* **Active Low Commission**: Nominate with reliable validators with low commissions.
* **From Favorites**: You can create a list of your favorite validators and nominate them.
* **Manual Selection**: You can manually select a maximum of 16 validators of your
choice to nominate.
Select one of these options and click on `Continue`.
### Enter the bond amount
Enter the total amount of AVAIL you want to stake. The minimum amount for direct nomination
is 1000 AVAIL. Click on `Continue`.
> **Warning**
>
> **DON'T STAKE ALL YOUR AVAIL**
> Each transaction on Avail DA requires a small amount of AVAIL to be paid as fees.
> We highly recommend you keep a small unstaked balance that you might need to initiate any other transactions.
### Start Nominating
Once all your configurations are set, the dashboard allows you to review your sleections
one last time.
If you're happy with everything, click on `Start Nominating`. At this point, you will
need to approve the transaction in your wallet.
### Happy nominating!
And that's it! This guide walked you through nominating your AVAIL directly to validators
of your choice. Go to the next page to learn how to work with nomination pools.
### Rewards from direct nomination
Rewards accrued via direct nomination are payed out to **ALL STAKERS** of a particular validator when either of the three happens:
1. You click on the `claim` button to claim your rewards. All stakers of the validator will have their rewards payed out.
2. The validator themselves claim their rewards. Again, all stakers of the validator, which includes you, will have their rewards payed out.
3. When one of the stakers apart from you claims their rewards. No points for guessing, all stakers of the validator will have their rewards payed out.
What happens with your stake depends on the choice you made in `Step 5`:
* **Compound**: This will automatically add your rewards to your existing stake, thus compunding it.
* **To Your Account**: This will send your rewards to the account you used to stake.
* **To Another Account**: This will send your rewards to the account you specified.
### How to Create Nomination Pools on Avail
## What Are Nomination Pools?
Nomination pools are a critical feature in Avail's consensus system, akin to those in [Polkadot and Substrate](https://wiki.polkadot.network/docs/learn-nomination-pools), They allow users to combine their stakes, effectively acting as a single nominator. This approach addresses the limitations of individual small stakes and ensures more efficient participation in the staking process.
### Join the pool
Once you have configured your settings, you can join the pool with any amount ≥ 100 AVAIL. Simply
click on `Join Pool` and approve the transaction.
> **Warning**
>
> **DON'T STAKE ALL YOUR AVAIL**
> Each transaction on Avail DA requires a small amount of AVAIL to be paid as fees.
> We highly recommend you keep a small unstaked balance that you might need to initiate any other transactions.
> **Note**
>
> Please note that this tutorial showed you how to join a recommended nomination pool on Avail by clicking on the `Ready to Join Pool` button.
> You can view a list of all available pools by going to [staking.availproject.org/#/pools](https://staking.availproject.org/#/pools)
> and clicking on `All Pools`.
> There you can check out a list of all available pools on Avail DA and join the one that you want.
### Withdraw your rewards from the pool
After a few days you will see `unclaimed rewards` adding up for your account in the staking dashboard.
You can either withdraw these rewards to your account or compound them back into the pool. \
To withdraw your rewards, click on the `Withdraw` button and approve the transaction. You will then receive your rewards in your account. \
By clicking on the `Compound` button, you can restake your rewards back into the pool.
> **Warning**
>
> **PLEASE NOTE**
> The rewards you earn for staking AVAIL to nomination pools are not automatically transferred to your account.
> You need to manually sign a `withdraw` transaction to claim your rewards.
## Create a new nomination pool
> **Note**
>
> PREREQUISITES
> The only prerequisite for creating a new nomination pool on Avail DA is that you have an Avail DA
> compatible wallet with a minimum of 10000 AVAIL in it.
### Get set up as before
Go to [staking.availproject.org/#/pools](https://staking.availproject.org/#/pools) and make sure you have connected a wallet
to the website that has sufficient funds to create a pool.
### Name your pool
Click on `Create Pool` and enter a name for your pool. This name will be visible to all users.
### Nominate validators for your pool
You can nominate upto 16 validators for your pool, with a few different options to come up with your list.
This is very similar to how validators are selected for direct nomination. You can check out the
[docs here](/docs/da/user-guides/staking-governance/stake-on-avail/direct-nomination#choose-your-validators) for reference.
### Delegate roles for your pool
A nomination pool on Avail DA has 4 different roles. You can read about them [up in the page](#roles-within-a-pool), under the
`Pool Administration` block.
You can delegate all the roles except the Depositor to addresses of your choices, which will always be the address that
created the pool.
### Enter the bond amount
Enter the amount of AVAIL you want to bond to the pool. 10000 AVAIL is the minimum amount needed to create the
pool, and other users can deposit more AVAIL to the pool to join it.
> **Warning**
>
> **DON'T STAKE ALL YOUR AVAIL**
> Each transaction on Avail DA requires a small amount of AVAIL to be paid as fees.
> We highly recommend you keep a small unstaked balance that you might need to initiate any other transactions.
### Create the pool
One everything is done, take a good look at the summary and click on the `Create Pool` button.
Approve the transaction that pops up.
> **Note**
>
> As the pool owner you will have the privilege of setting various parameters for the pool once it is created,
> which will affect the rewards distribution and the pool's overall performance.
> Read below for more information on the same.
Wallet Status:{" "}
{isConnected ? "Connected" : "Not connected"}
SDK Status:{" "}
{initialized ? "Initialized" : "Not initialized"}
{balances && (
{JSON.stringify(balances, null, 2)}
)}
{bridgeResult && (
{JSON.stringify(bridgeResult, null, 2)}
)}
{depositResult && (
{JSON.stringify(depositResult, null, 2)}
)}