Learn to build on Avalanche with Figment Learn

Avalanche 101

Avalanche is an open-source platform for launching highly decentralized applications, new financial primitives, and new interoperable blockchains.

Avalanche

< 1 hour

1 hour

Beginner

Intermediate

JS/TS

Solidity

EVM compatibility

React

NodeJS

Smart contracts

Truffle

Javascript

Metamask

Remix

Avash

Waffle

Hardhat

Next.js

DeFi

Tools & Infra

Time Commitment

Difficulty

Programming Language

Feature

Technology

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/platform/create-a-local-test-network). 

# Introduction

In the [quickstart tutorial](https://docs.avax.network/build/getting-started) we connect a node to the test network. You might find it useful to create a local test network.

We’ll show you how to launch a 5 node local test network. For both we’ll show how to launch the network using [Avash](https://docs.avax.network/build/tools/avash) and manually.

The 5 nodes will have HTTP ports $where API calls should be sent$ `9650`, `9652`, `9654`, `9656` and `9658`.

# Create a Local Test Network

The below commands assume you have AvalancheGo installed at `$GOPATH/src/github.com/ava-labs/avalanchego`. Each of the five nodes created is a validator. The staking keys for these nodes are in `$GOPATH/src/github.com/ava-labs/avalanchego/staking/local/staker1.crt`, etc.

# Manually

To start the network:

```javascript
cd $GOPATH/src/github.com/ava-labs/avalanchego
./scripts/build.sh
./build/avalanchego --public-ip=127.0.0.1 --snow-sample-size=2 --snow-quorum-size=2 --http-port=9650 --staking-port=9651 --db-dir=db/node1 --staking-enabled=true --network-id=local --bootstrap-ips= --staking-tls-cert-file=$(pwd)/staking/local/staker1.crt --staking-tls-key-file=$(pwd)/staking/local/staker1.key
./build/avalanchego --public-ip=127.0.0.1 --snow-sample-size=2 --snow-quorum-size=2 --http-port=9652 --staking-port=9653 --db-dir=db/node2 --staking-enabled=true --network-id=local --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=$(pwd)/staking/local/staker2.crt --staking-tls-key-file=$(pwd)/staking/local/staker2.key
./build/avalanchego --public-ip=127.0.0.1 --snow-sample-size=2 --snow-quorum-size=2 --http-port=9654 --staking-port=9655 --db-dir=db/node3 --staking-enabled=true --network-id=local --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=$(pwd)/staking/local/staker3.crt --staking-tls-key-file=$(pwd)/staking/local/staker3.key
./build/avalanchego --public-ip=127.0.0.1 --snow-sample-size=2 --snow-quorum-size=2 --http-port=9656 --staking-port=9657 --db-dir=db/node4 --staking-enabled=true --network-id=local --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=$(pwd)/staking/local/staker4.crt --staking-tls-key-file=$(pwd)/staking/local/staker4.key
./build/avalanchego --public-ip=127.0.0.1 --snow-sample-size=2 --snow-quorum-size=2 --http-port=9658 --staking-port=9659 --db-dir=db/node5 --staking-enabled=true --network-id=local --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=$(pwd)/staking/local/staker5.crt --staking-tls-key-file=$(pwd)/staking/local/staker5.key
```

# With Avash

We assume you’ve installed [Avash](https://docs.avax.network/build/tools/avash).

To open Avash:

```javascript
cd $GOPATH/src/github.com/ava-labs/avash
go build
./avash
```

Now we’re in Avash. To start the network:

```javascript
runscript scripts/five_node_staking.lua
```

When you want to tear down the network, run `exit` to exit Avash.

# Verifying nodes are connected

We can look at one of the node’s peers to ensure that the nodes are connected. To do so, call `info.peers`.

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"info.peers"
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/info
```

`peers` should have 4 entries:

```javascript
{
   "jsonrpc":"2.0",
   "result":{
      "peers":[
         {
            "ip":"127.0.0.1:9158",
            "publicIP":"127.0.0.1:9158",
            "id":"NwEmCRVweJs9vTin7LpnweWSKVP4AB9Qi",
            "version":"avalanche/0.5.0",
            "lastSent":"2020-06-01T19:41:08Z",
            "lastReceived":"2020-06-01T19:41:08Z"
         },
         {
            "ip":"127.0.0.1:9156",
            "publicIP":"127.0.0.1:9156",
            "id":"6f3yBqjAJYV3tpBHLJKYruY3dPHAzKFEE",
            "version":"avalanche/0.5.0",
            "lastSent":"2020-06-01T19:41:08Z",
            "lastReceived":"2020-06-01T19:41:08Z"
         },
         {
            "ip":"127.0.0.1:9155",
            "publicIP":"127.0.0.1:9155",
            "id":"KxLwPp9MYV26CoP8ixTXggWvEgVaa9iPN",
            "version":"avalanche/0.5.0",
            "lastSent":"2020-06-01T19:41:08Z",
            "lastReceived":"2020-06-01T19:41:08Z"
         },
         {
            "ip":"127.0.0.1:9157",
            "publicIP":"127.0.0.1:9157",
            "id":"CkcATAFTDK4HHNWycEWfCz5wEMCsssZSt",
            "version":"avalanche/0.5.0",
            "lastSent":"2020-06-01T19:41:08Z",
            "lastReceived":"2020-06-01T19:41:08Z"
         }
      ]
   },
   "id":1
}
```

# Getting AVAX

When running a network with `--network-id=local`, as we’ve done, there is a pre-funded X-Chain address that you can import in order to get AVAX. The private key for this address is `PrivateKey-ewoqjP7PxY4yr3iLTpLisriqt94hdyDFNgchSxGGztUrTXtNN`. After you create a keystore user on a node, you can import this key, and the funds it holds, with:

```javascript
curl --location --request POST 'localhost:9650/ext/platform' \
--header 'Content-Type: application/json' \
--data-raw '{
    "jsonrpc": "2.0",
    "method": "platform.importKey",
    "params":{
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE",
          "privateKey":"PrivateKey-ewoqjP7PxY4yr3iLTpLisriqt94hdyDFNgchSxGGztUrTXtNN"
    },
    "id": 1
}'
```

That’s it! Your local Avalanche network is up and running. It has the default blockchains: the X-Chain, C-Chain and P-Chain. The only Subnet that exists is the Primary Network.

You can add more nodes to the network. Just remember to give unique values for `db-dir`, `http-port` and `staking-port`.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to create a local test network on Avalanche

Create a Local Test Network

Learn to build an advanced e-Voting dApp on Avalanche Fuji testnet using Trufflesuite.

Advanced e-Voting dApp on avalanche

# Introduction

[Avash](https://github.com/ava-labs/avash) is a temporary stateful shell client which can be used for various purposes like deploying local Avalanche networks, managing their processes, and for running network tests. However, once we exit from Avash, this local copy of Avalanche stops running and all its history and transactions are lost. This provides us with the opportunity to experiment with the properties and behaviour of Avalanche networks on our local system without needing to connect to the main Avalanche network.   
  
Avash also provides us with the ability to write scripts using Lua, to automate the creation of such networks and their configuration. [Lua](http://www.lua.org/) is highly portable scripting language which can be embedded into other applications, this is especially useful because of it's fast language engine with a small footprint. Lua is being used as the scripting language within Avash. In this tutorial, we're going to install a copy of Avash on our machine and create a Lua script that can be used to fire up a 5 node staking network $for testing purposes$.

# Requirements

For the smooth completion of this tutorial, we need the following software to be already present on your system:

* [Golang](https://golang.org/) $1.15.5+$

# AvalancheGo Installation

[AvalancheGo](https://github.com/ava-labs/avalanchego) is the official node implementation of the Avalanche network. Avash depends on an executable of this node implementation being present. So, we must install AvalancheGo before we attempt to run Avash.

To begin, look at the actual version of Golang which has been installed with the terminal command :

```
go version
```

## For go versions &lt; 1.16:

If the version number reported by `go version` is _less_ than v1.16 :

```
go get -v -d github.com/ava-labs/avalanchego/...
```

Since go 1.16, the module-aware mode is enabled by default, and this along with many other things, means that when we execute `go get ...`, the project gets downloaded to `$GOPATH/pkg/mod` and the permissions on this directory are set such that we won't be able to execute `scripts/build.sh` for building AvalancheGo and so we must turn this mode off for our installation of AvalancheGo.  
Hopefully this incompatibility between versions will be resolved in the future, but for now, we've got to take care of this ourselves.

## For go versions &gt;= 1.16:

If the version number reported by `go version` is _greater than_ **or** _equal to_ v1.16 :

```
GO111MODULE=off go get -v -d github.com/ava-labs/avalanchego/...
```

> Make sure that the environment variable GOPATH is already set. Usually, it is located at ~/go.


Now we change to the directory in which the project was downloaded and build it:

```text
cd $GOPATH/src/github.com/ava-labs/avalanchego
./scripts/build.sh
```

> If the build process fails, please make sure that the version of Golang installed on your machine is &gt; 1.15.5.

After the build process is complete, you can find the AvalancheGo binary, named `avalanchego`, inside the `build` directory.

# Avash Installation

Now we go onto install Avash. Unlike AvalancheGo, Avash needs the module-aware mode enabled for it to be successfully installed.

```
go get github.com/ava-labs/avash
```

If this command fails to execute with similar errors like below, that means we've got to turn on the module-aware mode explicitly.

```text
cannot find package "github.com/decred/dcrd/dcrec/secp256k1/v3" in any of:
/snap/go/7416/src/github.com/decred/dcrd/dcrec/secp256k1/v3 (from $GOROOT)
~/go/src/github.com/decred/dcrd/dcrec/secp256k1/v3 (from $GOPATH)
cannot find package "github.com/decred/dcrd/dcrec/secp256k1/v3/ecdsa" in any of:
/snap/go/7416/src/github.com/decred/dcrd/dcrec/secp256k1/v3/ecdsa (from $GOROOT)
~/go/src/github.com/decred/dcrd/dcrec/secp256k1/v3/ecdsa (from $GOPATH)
cannot find package "github.com/hashicorp/hcl/hcl/printer" in any of:
/snap/go/7416/src/github.com/hashicorp/hcl/hcl/printer (from $GOROOT)
~/go/src/github.com/hashicorp/hcl/hcl/printer (from $GOPATH)
#cd .; git clone -- https://github.com/chzyer/readline /home/kevin/go/src/github.com/chzyer/readline
Cloning into '~/go/src/github.com/chzyer/readline'...
fatal: unable to access 'https://github.com/chzyer/readline/': gnutls_handshake() failed: Error in the pull function.
package github.com/chzyer/readline: exit status 128
```

To continue, we use the same command as before but we pass in an extra environment variable to explicitly turn on module-aware mode :

```
GO111MODULE=on go get github.com/ava-labs/avash
```

Now we have the source code for Avash downloaded onto our machines. Again, we have some differences in behaviour based which Golang version is being used.

## For go versions &lt; 1.16:

For those who're using go versions &lt; 1.16, you will have to manually build the Avash source:

```
cd $GOPATH/src/github.com/ava-labs/avash
go build
```

After the the project is built successfully, the Avash binary should be present in the same directory. To verify this, try:

```
cd $GOPATH/bin
./avash
```

You will be greeted with the Avash console:

```text
avash>
```

Now you've successfully installed and run Avash on your machine! To exit from Avash, type `exit` into the console and press enter.

## For go versions &gt;= 1.16:

In this case, the Avash code gets automatically built after being downloaded and you can find the binary available at `$GOPATH/bin` directory. To verify this, try:

```
cd $GOPATH/bin
./avash
```

You will then be greeted with the Avash console:

```text
avash>
```

# Adding Lua scripts

Now that we have a successful installation of Avash on our machine, we can add a Lua script that we'll use to start up a local Avalanche network.

## For go versions &lt; 1.16:

We need to add a configuration file and a Lua script to the `scripts` directory inside the Avash installation.

```text
cd $GOPATH/src/github.com/ava-labs/avash
```

The configuration below will be used inside the Lua script when starting the nodes. The main difference in configuration between this node and the official `five_node_staking.lua` script is that for the nodes we run locally, we enable a personal namespace with "personal-api-enabled" in `coreth-config` which is normally disabled by default.   
This will be useful later on in other tutorials regarding smart contracts using truffle, hardhat, waffle, etc.

`scripts/config/staking\_node\_config.json` :
```json
{
  "db-enabled": false,
  "staking-enabled": true,
  "log-level": "debug",
  "coreth-config": {
    "snowman-api-enabled": false,
    "coreth-admin-api-enabled": false,
    "net-api-enabled": true,
    "rpc-gas-cap": 2500000000,
    "rpc-tx-fee-cap": 100,
    "eth-api-enabled": true,
    "tx-pool-api-enabled": true,
    "debug-api-enabled": true,
    "web3-api-enabled": true,
    "personal-api-enabled": true
  }
}
```
Next comes our Lua script itself :

`five\_node\_staking.lua` :
```lua
cmds = {
"startnode node1 --config-file=scripts/config/staking_node_config.json --http-port=9650 --staking-port=9651 --bootstrap-ips= --staking-tls-cert-file=certs/keys1/staker.crt --staking-tls-key-file=certs/keys1/staker.key",
"startnode node2 --config-file=scripts/config/staking_node_config.json --http-port=9652 --staking-port=9653 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=certs/keys2/staker.crt --staking-tls-key-file=certs/keys2/staker.key",
"startnode node3 --config-file=scripts/config/staking_node_config.json --http-port=9654 --staking-port=9655 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=certs/keys3/staker.crt --staking-tls-key-file=certs/keys3/staker.key",
"startnode node4 --config-file=scripts/config/staking_node_config.json --http-port=9656 --staking-port=9657 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=certs/keys4/staker.crt --staking-tls-key-file=certs/keys4/staker.key",
"startnode node5 --config-file=scripts/config/staking_node_config.json --http-port=9658 --staking-port=9659 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=certs/keys5/staker.crt --staking-tls-key-file=certs/keys5/staker.key",
}

for key, cmd in ipairs(cmds) do
avash_call(cmd)
end
```


## For go versions &gt;= 1.16:

For more recent versions of Golang, the workflow is slightly different. We need to add a configuration file and a Lua script to the `avash_scripts` directory inside of the home directory of the current user.

```text
mkdir ~/avash_scripts
cd ~/avash_scripts
```

The configuration below will be used inside the Lua script when starting the nodes. The main difference in configuration between this node and the official `five_node_staking.lua` script is that for the nodes we run locally, we enable a personal namespace with "personal-api-enabled" in `coreth-config` which is normally disabled by default. 


```json
{
  "db-enabled": false,
  "staking-enabled": true,
  "log-level": "debug",
  "coreth-config": {
    "snowman-api-enabled": false,
    "coreth-admin-api-enabled": false,
    "net-api-enabled": true,
    "rpc-gas-cap": 2500000000,
    "rpc-tx-fee-cap": 100,
    "eth-api-enabled": true,
    "tx-pool-api-enabled": true,
    "debug-api-enabled": true,
    "web3-api-enabled": true,
    "personal-api-enabled": true
  }
}
```

Next comes our Lua script itself:

> You have to replace all occurrences of **avash@v1.1.4** in the file below with the actual version of Avash that is installed on your machine - **avash@v{your\_version}**. 
> It occurs twice on each line, in the paths for `--staking-tls-cert-file` and `--staking-tls-key-file`   
> Search and Replace functionality is a good choice for this task $Ctrl+F or ⌘-F in most text editors$.


`five\_node\_staking\_with\_config.lua`
```lua
cmds = {
"startnode node1 --config-file=../../avash_scripts/config/staking_node_config.json --http-port=9650 --staking-port=9651 --bootstrap-ips= --staking-tls-cert-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys1/staker.crt --staking-tls-key-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys1/staker.key",
"startnode node2 --config-file=../../avash_scripts/config/staking_node_config.json --http-port=9652 --staking-port=9653 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys2/staker.crt --staking-tls-key-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys2/staker.key",
"startnode node3 --config-file=../../avash_scripts/config/staking_node_config.json --http-port=9654 --staking-port=9655 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys3/staker.crt --staking-tls-key-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys3/staker.key",
"startnode node4 --config-file=../../avash_scripts/config/staking_node_config.json --http-port=9656 --staking-port=9657 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys4/staker.crt --staking-tls-key-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys4/staker.key",
"startnode node5 --config-file=../../avash_scripts/config/staking_node_config.json --http-port=9658 --staking-port=9659 --bootstrap-ips=127.0.0.1:9651 --bootstrap-ids=NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg --staking-tls-cert-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys5/staker.crt --staking-tls-key-file=../pkg/mod/github.com/ava-labs/avash@v1.1.4/certs/keys5/staker.key",
}

for key, cmd in ipairs(cmds) do
avash_call(cmd)
end
```

# Setup a local Avalanche network using Avash

In the last section, we've added the Lua script in the appropriate location, which we can now use to fire up the nodes from the Avash console.

## For go versions &lt; 1.16:

To start a local five node Avalanche network, follow these steps:

```text
cd $GOPATH/src/github.com/ava-labs/avash
$ ./avash
```

You must be looking at the Avash prompt as shown below:

```text
avash>
```

Now you need to run the script we created in the previous section, which will start a local five-node network on your machine.

```text
runscript scripts/five_node_staking_with_config.lua
```

The nodes will start up successfully, and the console will display the output:

```text
avash> runscript scripts/five_node_staking_with_config.lua
RunScript: Running scripts/five_node_staking_with_config.lua
RunScript: Successfully ran scripts/five_node_staking_with_config.lua
```

## For go versions &gt;= 1.16:

To start a local five-node Avalanche network, follow these steps:

```text
cd $GOPATH/bin
./avash
```

You must be looking at the Avash prompt as shown below:

```text
avash>
```

Now you need to run the script we created in the last section which will start a local five-node staking network on your machine.

```text
runscript ../../avash_scripts/five_node_staking_with_config.lua
```

The nodes will start up successfully, and the console will display the output:

```text
avash> runscript ../../avash_scripts/five_node_staking_with_config.lua
RunScript: Running ../../avash_scripts/five_node_staking_with_config.lua
RunScript: Successfully ran ../../avash_scripts/five_node_staking_with_config.lua
```

# Interacting with the local Avalanche network

To interact with the running Avalanche network, open up a new terminal and type in the following command:

> Pasting this into a Windows terminal will cause an error because Windows does not use the backslash as a multiline separator.  
> Replace the `\` slashes with carets `^` if you plan on pasting this into a Windows terminal $PowerShell or cmd.exe$.


```
curl --location --request POST 'http://localhost:9650/ext/info' \
--header 'Content-Type: application/json' \
--data-raw '{"jsonrpc":"2.0","id":1, "method" :"info.getBlockchainID", "params": {"alias": "X"}}'
```

This should return a response similar to what you can see below:

```text
{"jsonrpc":"2.0","result":{"blockchainID":"2eNy1mUFdmaxXNj1eQHUe7Np4gju9sJsEtWQ4MX3ToiNKuADed"},"id":1}
```

> Remember, do not close the Avash terminal window until you are done working with the local nodes. When the terminal is closed, the local Avalanche network gets destroyed along with it.

When you're all done experimenting with the local Avalanche network, type `exit` into the Avash console and press enter. This closes the Avash terminal and with it, all the nodes started during its lifetime, essentially destroying the temporary local Avalanche network we created using the Lua script.

# Conclusion

In this tutorial, we've successfully managed to install Avash, create a Lua script that fires up a five-node staking network on your machine, and fire it up and interact with the network from the terminal.

Congratulations on making it to the end of this tutorial!

> “No great thing is created suddenly, any more than a bunch of grapes or a fig. If you tell me that you desire a fig, I answer that there must be time. Let it first blossom, then bear fruit, then ripen.”
>
> -- Epictetus

So, keep learning and keep building and you're on your way to making something great! Good luck!

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can join [**our community**](https://discord.gg/fszyM7K) today!

# References

* [AvalancheGo Readme](https://github.com/ava-labs/avalanchego/blob/master/README.md)
* [Avash Documentation](https://docs.avax.network/build/tools/avash)


Learn how to setup and run a local Avalanche network using Avash

Setting up a local Avalanche network using Avash

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/smart-digital-assets/create-a-fix-cap-asset). 

# Introduction

This tutorial illustrates how Avalanche can be used to create and trade a fixed-cap, fungible asset. A quantity of the asset is created at the asset’s initialization, and then no more is ever created.

Suppose there is an Income Sharing Agreement $ISA$ with 10M shares, and no more shares are ever created. Let’s create an asset where one unit of the asset represents one share of the ISA.

### Assumptions

We assume that you’re already familiar with [**DataHub**](https://datahub.figment.io/sign_up?service=avalanche) and connecting to the Avalanche services.

## Create the Asset

Our asset will exist on the [X-Chain](https://docs.avax.network/learn/platform-overview#exchange-chain-x-chain), so to create our asset we’ll call `avm.createFixedCapAsset`, a method of the [X-Chain’s API](https://docs.figment.io/network-documentation/avalanche/rpc-and-rest-api/).

The signature for this method is:

```javascript
avm.createFixedCapAsset({
    name: string,
    symbol: string,
    denomination: int,  
    initialHolders: []{
        address: string,
        amount: int
    },
    from: []string,
    changeAddr: string,
    username: string,  
    password: string
}) ->
{
    assetID: string,
    changeAddr: string,
}
```

#### Parameters <a id="parameters"></a>

* `name` is a human-readable name for the asset. Not necessarily unique.
* `symbol` is a shorthand symbol for the asset. Between 0 and 4 characters. Not necessarily unique. May be omitted.
* `denomination` determines how balances of this asset are displayed by user interfaces. If denomination is 0, 100 units of this asset are displayed as 100. If denomination is 1, 100 units of this asset are displayed as 10.0. If denomination is 2, 100 units of this asset are displays as .100, etc.
* Performing a transaction on the X-Chain require a transaction fee paid in AVAX. `username` and `password` denote the user paying the fee.
* Each element in `initialHolders` specifies that `address` holds `amount` units of the asset at genesis.
* `from` are the addresses that you want to use for this operation. If omitted, uses any of your addresses as needed.
* `changeAddr` is the address any change will be sent to. If omitted, change is sent to one of the addresses controlled by the user.

#### Response <a id="response"></a>

* `assetID` is the ID of the new asset.
* `changeAddr` in the result is the address where any change was sent.

Now, on to creating the asset. You’ll want to replace `address` with an address your user controls so that you will hold all of the newly created asset and be able to send it later in this tutorial.

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.createFixedCapAsset",
    "params" :{
        "name": "ISA Shares",
        "symbol":"ISAS",
        "denomination": 0,
        "initialHolders": [
            {
                "address": "X-avax10pvk9anjqrjfv2xudkdptza654695uwc8ecyg5",
                "amount": 10000000
            }
        ],
        "from":["X-avax1s65kep4smpr9cnf6uh9cuuud4ndm2z4jguj3gp"],
        "changeAddr":"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response contains the asset’s ID, which is also the ID of this transaction:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "assetID":"keMuoTQSGjqZbNVTCcbrwuNNNv9eEEZWBaRY3TapcgjkoZmQ1",
        "changeAddr":"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8"
    }
}
```

## Trade the Asset

#### Check a balance <a id="check-a-balance"></a>

All 10,000,000 units of the asset $shares$ are controlled by the address we specified in `initialHolders`.

To verify this we call `avm.getBalance`:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-avax10pvk9anjqrjfv2xudkdptza654695uwc8ecyg5",
        "assetID":"keMuoTQSGjqZbNVTCcbrwuNNNv9eEEZWBaRY3TapcgjkoZmQ1"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response confirms that our asset creation was successful, and that the expected address holds all 10,000,000 shares:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "balance":10000000
    }
}
```

#### Send the asset <a id="send-the-asset"></a>

Now, let’s send 100 shares by calling `avm.send`.

To send the shares, we need to prove that we control the user the shares are being sent from. Therefore, this time we’ll need to fill in `username` and `password`.

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.send",
    "params" :{
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE",
        "assetID" :"keMuoTQSGjqZbNVTCcbrwuNNNv9eEEZWBaRY3TapcgjkoZmQ1",
        "amount"  :100,
        "to"      :"X-avax1t8sl0knfzly3t3sherctxwezy533ega3sxww2k"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

#### Check the transaction status <a id="check-the-transaction-status"></a>

The response from the above call should look like this:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "txID":"2EAgR1YbsaJrwFiU4DpwjUfTLkt97WrjQYYNQny13AheewnxSR",
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8"
    }
}
```

`txID` is the ID of the `send` transaction we sent to the network.

After a second or two, the transaction should be finalized. We can check the status of the transaction with `avm.getTxStatus`:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getTxStatus",
    "params" :{
        "txID":"2EAgR1YbsaJrwFiU4DpwjUfTLkt97WrjQYYNQny13AheewnxSR"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response should look like this

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "status":"Accepted"
    }
}
```

You might also see that `status` is `Pending` if the network has not yet finalized it yet.

Now let’s check the balance of the `to` address:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-avax1t8sl0knfzly3t3sherctxwezy533ega3sxww2k",
        "assetID":"keMuoTQSGjqZbNVTCcbrwuNNNv9eEEZWBaRY3TapcgjkoZmQ1"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response should be:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "balance":100
    }
}
```

## Wrapping up

In this tutorial, we:

* Called `createFixedCapAsset` to create a fixed cap asset
* Called `getBalance` to check address balances
* Called `send` to transfer a quantity of our asset

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to create a fixed-cap asset on Avalanche

Creating A Fixed-Cap Asset

# What is Avalanche?

Avalanche is a layer one protocol by Ava Labs that offers high-throughput, fast finality, and unprecedented decentralization. Developers are able to launch their own public or private blockchains (called subnets), create and trade digital assets, and build scalable smart contracts and decentralized applications.

Subnets within the Avalanche network will be highly customizable and will have their own incentive structures.

Because of this customization, companies can create legally compliant permissioned subnets while still being connected to the grander Avalanche network. This could lead to the creation of new financial primitives and bring more traditional financial products into the blockchain space in a decentralized way.

## Why build on Avalanche?

AVA was created to fill use cases that existing platforms are unable to provide while retaining the promise of decentralization. People who use Avalanche do so because they need to support their high-throughput systems but do not wish to rely on a trusted intermediary. With the ability to partition private data away from the rest of the Avalanche network while still being a member of the overall network, Avalanche enables the privacy use cases other platforms do not.

With fast decision times and reasonable hardware requirements, Avalanche powers a system that can accept many times the data and productive yield than existing decentralized systems provide at a low cost to the end user. Avalanche is an asset engine that can deploy and power new markets or integrate existing ones into a global exchange backbone.

## What can you build on Avalanche?

Avalanche provides developers with one of the most versatile protocols available today. Developers can:

* Create their own VM for their needs
* Create their subnets (private and public), to customize their value proposition 
* Create as many chains as needed under their subnet
* Use (almost) the full suite of Ethereum smart contracts right off the shelf 
* Create native NFTs as first-order objects
* Create powerful decentralized financial applications

And more!

# Network Specifications

## Transaction Fees

In order to prevent spam, transactions on the Avalanche network require the payment of a transaction fee. The fee is paid in AVAX, Avalanche’s native token.

The transaction fee is burned. That is, the AVAX tokens paid in a transaction fee do not go to anywhere. Instead, they are destroyed forever.

When you issue a transaction through Avalanche’s API, the transaction fee is automatically deducted from one of the addresses you control.

Different types of transactions require payment of a different transaction fee. This table shows the transaction fee schedule:

```text
+----------+-------------------+------------------------+
| Chain    : Transaction Type  | Transaction Fee (AVAX) |
+----------+-------------------+------------------------+
| P        : Create Blockchain |                   0.01 |
+----------+-------------------+------------------------+
| P        : Add Validator     |                      0 |
+----------+-------------------+------------------------+
| P        : Add Delegator     |                      0 |
+----------+-------------------+------------------------+
| P        : Create Subnet     |                   0.01 |
+----------+-------------------+------------------------+
| P        : Import AVAX       |                  0.001 |
+----------+-------------------+------------------------+
| P        : Export AVAX       |                  0.001 |
+----------+-------------------+------------------------+
| X        : Send              |                  0.001 |
+----------+-------------------+------------------------+
| X        : Create Asset      |                   0.01 |
+----------+-------------------+------------------------+
| X        : Mint Asset        |                  0.001 |
+----------+-------------------+------------------------+
| X        : Import AVAX       |                  0.001 |
+----------+-------------------+------------------------+
| X        : Export AVAX       |                  0.001 |
+----------+-------------------+------------------------+
```

The C-Chain gas price is 4.7e-7 AVAX/gas. The C-Chain gas limit is 10e8.

## Transaction Speed & Finality

Protocols in the Avalanche family are very fast. They can achieve irreversible finality in 1-2 seconds, quicker than a typical credit card transaction. They support many thousands of transactions per second, over Visa’s typical throughput.

Avalanche protocols are lightweight and sustainable. Unlike Nakamoto protocols, they use very little energy, and when there is no work to do, the system quiesces (waits in a low energy consumption state).

## Languages supported

Avalanche's C-Chain uses the standard Ethereum suite of tools.

The X-Chain and P-Chain use a Typescript library that supports native JavaScript cross-platform.

## EVM compatibility

The C-Chain is fully compatible with the EVM and provides support for any Ethereum applications as the EVM API is identical to Geth's API.

## Role of the AVAX token

AVAX is the Avalanche network's native token. All transactions on the Avalanche network require a fee denominated in AVAX.


Learn how Avalanche works and what makes it special

Introduction

# Introduction

An ERC721 token is a type of Non-Fungible Token $NFT$ which can contain or reference metadata in the form of art or digital content such as pictures, audio, social media posts, websites and even generative art projects in a broader perspective - even Virtual Reality and Augmented Reality!

An NFT is represented by a discrete unit of data on a digital ledger known as a blockchain, where each token represents some unique digital properties, that cannot be interchanged. These tokens enable many use cases that would be impossible with interchangeable or "fungible" tokens, like specific utility, proof of ownership, and a unique asset transaction history.

Refer to the official Ethereum developer documentation to learn more about [ERC-721 tokens](https://ethereum.org/en/developers/docs/standards/tokens/erc-721/).

# Prerequisites

In preparation for the tutorial, you will need to have a basic understanding of [Remix IDE](https://remix.ethereum.org/) and Solidity [smart contracts](https://solidity-by-example.org/). Please refer to the Avalanche [smart contract tutorial](https://learn.figment.io/network-documentation/avalanche/tutorials/deploy-a-smart-contract-on-avalanche-using-remix-and-metamask) for more information on the Avalanche wallet.

## Write a smart contract using Remix IDE

In the Remix IDE, create a new file and paste this ERC721 smart contract which imports the token standard from OpenZeppelin. The `import` lines will be processed by the Solidity compiler being run by the Remix IDE, and all of the dependencies $required files$ will be brought into the Remix workspace.

```javascript
// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract GameItem is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("GameItem", "ITM") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
}
```

This screenshot shows the main Remix IDE interface, with the Solidity code from above pasted into a new file called `ERC721.sol`

![](../../../.gitbook/assets/create-ERC721-contract.png)

Go to the second tab in the sidebar to compile the Solidity code, which will also fetch and install the OpenZeppelin boilerplate for ERC721 smart contracts which was specified by the `import` statements.

![](../../../.gitbook/assets/compile-and-install-deps.png)

Open the file ERC721.sol in the `.deps/npm/openzeppelin/contracts/token/ERC721/` directory to declare a royalties variable of the `uint8` type in the contract. This gives us the ability to specify the royalties as a number. The underscore before the variable name is to prevent [variable shadowing](https://en.wikipedia.org/wiki/Variable_shadowing).


```javascript
// .deps/npm/openzeppelin/contracts/token/ERC721/ERC721.sol
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Royalties
    uint8 private _royalties;
    
    ...
```

![](../../../.gitbook/assets/add-royalties-ERC721.png)

After declaring the royalties variable in the ERC721 contract, we must also initialize it in the constructor.


```javascript
    constructor(string memory name_, string memory symbol_, uint8 royalties_) {
        _name = name_;
        _symbol = symbol_;
        _royalties = royalties_;
    }
```


![](../../../.gitbook/assets/initialize-royalties-ERC721.png)

To get the current value of the royalties variable from the smart contract, create a public function `royalties()`, which can be set as a `view` type. We also want to make it `virtual` so that it can be overridden by any contract which inherits the function. It will return a `uint8` value, which matches the value that `_royalties` stores on the blockchain.


```javascript
    function royalties() public view virtual returns (uint8) {
        return _royalties;
    }
```


We can now compile the amended ERC721 smart contract and check for warnings, making sure the declared solidity version and compiler version are similar. The Solidity compiler uses [semantic versioning](http://semver.org/), so be aware that for example the version strings `0.8.0` and `^0.8.0` are not equal.

![](../../../.gitbook/assets/compile-ERC721.png)

Next, download and install the Metamask wallet for your browser. Create a new wallet in Metamask, then [follow our quick guide](https://learn.figment.io/network-documentation/avalanche/tutorials/deploy-a-smart-contract-on-avalanche-using-remix-and-metamask#step-1-setting-up-metamask) to connect to the Avalanche Fuji C-Chain. You will need to have a valid DataHub API key for Avalanche. 

Request AVAX from the test faucet for the deployment, from [https://faucet.avax-test.network/](https://faucet.avax-test.network/).

Pass the required parameters to the constructor in Remix: the Token Name, Symbol and Royalties. Then click the Deploy button!

![](../../../.gitbook/assets/ERC721-Deploy.png)

Still on the Deploy & Run Transactions tab in Remix, call the respective functions; _name_, _royalties_ and _symbol_ from the deployed ERC721 smart contract.

![](../../../.gitbook/assets/Deploy-And-Run-Transections.png)

Copy the address of the deployed contract to import in the Avalanche wallet. It should now appear on the collectibles tab in the portfolio section inside your [Avalanche wallet](https://wallet.avax.network/).

![](../../../.gitbook/assets/Add-Collectibles.png)

Congratulations! You have successfully added the NFT as collectible in the Avalanche wallet.

# Conclusion
Thank you for completing this tutorial, you should now know how to create an NFT with royalties on Avalanche using a simple Solidity smart contract. Have fun with it! If you would like to know the technical background of how NFTs work on the Avalanche network or would like to build products using NFTs, please check out this [Avalanche NFT tutorial](https://learn.figment.io/network-documentation/avalanche/tutorials/create-mint-transfer-nft)!.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://community.figment.io/) or [**Join our discord channel**](https://discord.gg/fszyM7K)!

# About the author

[Devendra Yadav](https://community.figment.io/u/dev.koold)

# References

This tutorial is based on the official [Avalanche Documentation](https://docs.avax.network/build/tutorials/smart-contracts/deploy-a-smart-contract-on-avalanche-using-remix-and-metamask).



Learn how to create an NFT with royalties on Avalanche.

Create an NFT with royalties on Avalanche using Remix IDE

# Introduction

In this tutorial, we are going to learn how to programatically transfer native AVAX tokens from the Avalanche C-Chain to a Metamask wallet.

# Prerequisites

* [Create an Avalanche wallet](https://wallet.avax.network/create)
* [Fund your Avalanche wallet with the FUJI Faucet](https://docs.avax.network/build/tutorials/platform/fuji-workflow#get-a-drip-from-the-fuji-faucet)
* [Transfer FUJI Avax tokens from X-chain to C-chain](https://docs.avax.network/build/tutorials/platform/transfer-avax-between-x-chain-and-c-chain)
* Having an integrated development environment, such as [Visual Studio Code](https://code.visualstudio.com/download)

# Requirements

* [NodeJS](https://nodejs.org/en)
* [Ethers](https://docs.ethers.io/v5/) and [web3](https://web3js.readthedocs.io/en/v1.5.2/), which you can install with `npm install ethers web3`
* Install [Metamask extension](https://metamask.io/download.html) in your browser.
* [Configure your Metamask to add Avalanche FUJI testnet](https://docs.avax.network/build/tutorials/smart-contracts/deploy-a-smart-contract-on-avalanche-using-remix-and-metamask#step-1-setting-up-metamask)  

# Transfer AVAX 

We are going to start by creating a new file called `AVAX_C_chain_to_ETH_address.js` in the root directory of your project. Once you create a .js file under the specified name, we will type in the following blocks of code in. 

First, we need to import Ethers and Web3 libraries mentioned under requirements in order to interact with the Avalanche C chain.

```javascript
const Web3 = require("web3")
const { ethers } = require('ethers')
```

The mnemonic key from your AVAX wallet needs to go between the quotation marks below. This is later used to extract the C-Chain wallet address.

```javascript
let mnemonic = "";
```

This code below is pointing to the Fuji network. Alternatively, we can point it to the Datahub AVAX node.

```javascript
const web3 = new Web3(new Web3.providers.HttpProvider("https://api.avax-test.network/ext/bc/C/rpc"))
```

Alternatively, the DataHub version would look as follows:

```javascript
const web3 = new Web3(new Web3.providers.HttpProvider(`https://avalanche--fuji--rpc.datahub.figment.io/apikey/${process.env.DATAHUB_AVALANCHE_API_KEY}/ext/bc/C/rpc`))
```

The DataHub version example above refers to the API key stored in the `.env` file. Refer to [Getting started with dotenv and .env files](https://docs.figment.io/network-documentation/extra-guides/dotenv-and-.env) for help. Sign up for a DataHub account to acquire an API key and store it in the `.env` file. 

The private key is needed to execute a transfer later on. With the mnemonic phrase provided earlier, we can obtain the private key to your AVAX wallet in the ETH address format with the colde below.

```javascript
const wallet = new ethers.Wallet.fromMnemonic(mnemonic);
AVAX_privatekey = wallet.privateKey;
```

The web3 package is designed to interact with an Ethereum blockchain and Ethereum smart contracts. The web3 module is capable of acting upon the AVAX implementation of the EVM. So, when interacting with the C chain, the web3 module is used. Here, `web3.eth.getBalance` fetches the AVAX balance. `result` in `web3.utils.fromWei` below is the balance of the account in the units of wei $the minimum unit of Ether is called wei and 1 Ether is 10^18 wei$. `fromWei` is a method in web3.utils, converting a number from one unit to another. So, `web3.utils.fromWei(result, "ether")` in the code below converts the balance from wei to ether. Since we are viewing the AVAX token balance, we will print AVAX at the end.

```javascript
async function main(){
    web3.eth.getBalance(wallet.address, function(err, result) {    
        if (err) {
          console.log(err)
        } else {
          console.log(web3.utils.fromWei(result, "ether") + " AVAX")
        }
    })
```
`console.log(web3.utils.fromWei(result, "ether") + " AVAX")` is what outputs the current balance on the C-chain of the sender's wallet. 

The block below is to view the \# of transactions associated with the wallet address $not necessary for the purpose of AVAX transfer from C chain to an ETH address$ but could be useful when you later want to transfer an ERC20 token.

```javascript
    web3.eth.getTransactionCount(wallet.address)       
    .then(console.log);                                               
    const createTransaction = await web3.eth.accounts.signTransaction(           
        {
           gas: 21000,
```

`web3.eth.getTransactionCount(wallet.address).then(console.log)` is the portion of the script that outputs the number of transactions that have happened in the account so far. 

Moving on, copy and paste your Metamask wallet address (or any ETH format address) beween the quotation marks below

```javascript
           to:"",
```

Below, we need to input how many tokens are to be transferred out of your AVAX wallet off the C chain. Currently the amount is arbitrarily set to 0.15 AVAX tokens as an example $0.15 tokens in the line below$.

```javascript
           value: web3.utils.toWei('0.15', 'ether'),     
        },
        AVAX_privatekey                                 
     );
     const createReceipt = await web3.eth.sendSignedTransaction(
        createTransaction.rawTransaction
     );
     console.log(
        `Transaction successful with hash: ${createReceipt.transactionHash}`
     );
  };
main().catch((err) => {
    console.log("We have encountered an error!")
    console.error(err)
})
```

At this point, the transfer should have completed. \`Transaction successful with hash: ${createReceipt.transactionHash}\` outputs the transaction hash to the terminal. This is your transaction record.

At this point, you have gone through the entire script. 

The finished script should look as follows:

```javascript
const Web3 = require("web3")
const { ethers } = require('ethers')
let mnemonic = "";
const web3 = new Web3(new Web3.providers.HttpProvider("https://api.avax-test.network/ext/bc/C/rpc"))
const wallet = new ethers.Wallet.fromMnemonic(mnemonic);
AVAX_privatekey = wallet.privateKey;

async function main(){
    web3.eth.getBalance(wallet.address, function(err, result) {    
        if (err) {
          console.log(err)
        } else {
          console.log(web3.utils.fromWei(result, "ether") + " AVAX")
        }
    })
    web3.eth.getTransactionCount(wallet.address)       
    .then(console.log);                                               
    const createTransaction = await web3.eth.accounts.signTransaction(           
        {
           gas: 21000,
           to:"",
           value: web3.utils.toWei('0.15', 'ether'),     
        },
        AVAX_privatekey                                 
     );
     const createReceipt = await web3.eth.sendSignedTransaction(
        createTransaction.rawTransaction
     );
     console.log(
        `Transaction successful with hash: ${createReceipt.transactionHash}`
     );
  };
main().catch((err) => {
    console.log("We have encountered an error!")
    console.error(err)
})
```

To run the script `AVAX_C_chain_to_ETH_address.js`, type `node AVAX_C_chain_to_ETH_address.js` and run it in your terminal (`node` before the file name is the way to invoke the NodeJS runtime environment).

# Troubleshooting

## Transaction Failure

* Check if you have sufficient balance in your Avalanche wallet. 

Not having sufficient balance would result in the following error in your terminal. 

![example](https://i.imgur.com/Jh2a6Yl.png)  

Make sure that your balance on the C-chain is sufficient as shown below

![example](https://i.imgur.com/d2QFBU0.png)

# Conclusion

This tutorial has taught you how to transfer AVAX native tokens from the C chain to an ETH wallet. Also, this has shown how Avalanche blockchain C chain is compatible with the popular web3.js library. This is a powerful aspect of the Avalanche blockchain, as it allows Ethereum developers to easily port their work over to Avalanche.

Try transferring your Fuji AVAX tokens by running this script and see if it worked.

When everything was run as expected, the output in the terminal should look similar to what we have below.

![example](https://i.imgur.com/yr6nkto.png)

# About the author

This tutorial was created by [Seongwoo Oh](https://github.com/blackwidoq). He is a student and an Avalanche novice.


Learn how to transfer AVAX tokens from C-Chain to an Ethereum address

Transfer AVAX from C-Chain to an Ethereum address

[Avalanche.js](https://github.com/ava-labs/avalanchejs) is a client JavaScript package that makes it easy to interact with Avalanche blockchain nodes, query data, submit transactions and offers plenty of other functionality. It's the official package developed by Avalanche, and is a preferred method of communicating with nodes on the private or public networks for development purposes.

In this tutorial, we will learn how to connect to an Avalanche node using DataHub. You will need to complete the code in each tutorial, to make the dApp functional.

---

# Challenge

{% hint style="tip" %}
In `pages/api/avalanche/connect.ts`, implement the function and try to establish your first connection to the Avalanche network. To verify your connection has been correctly established, try to return the current protocol version. You must replace any instances of `undefined` with working code to accomplish this.
{% endhint %}

```typescript
//...
  try {
    const {network} = req.body;
    const client = undefined;
    const info = undefined;
    const version = undefined;
    if (version === undefined) {
      throw new Error('Connection failed: Complete the code');
    }
    res.status(200).json(version);
  }
//...
```

**Need some help?** Check out these tips

- [**Check out the `AvalancheJS` library**](https://github.com/ava-labs/avalanchejs)
- Use the `getAvalancheClient` helper function.
- Use the `Info` method on the client.
- Use the `getNodeVersion` method on the client info (remember to `await` this call).

{% hint style="info" %}
You can [**join us on Discord**](https://discord.gg/fszyM7K), if you have questions or want help completing the tutorial.
{% endhint %}

Still not sure how to do this? No problem! The solution is below so you don't get stuck.

---

# Solution

```typescript
// solution
//...
  try {
    const {network} = req.body;
    const client = getAvalancheClient(network);
    const info = client.Info();
    const version = await info.getNodeVersion();
    if (version === undefined) {
      throw new Error('Connection failed: Complete the code');
    }
    res.status(200).json(version);
  }
//...
```

**What happened in the code above?**

- We instantiate an `Avalanche` object with `getAvalancheClient` passing to it the selected `network`.
- Calling the `Info` method on the `AvalancheClient` module returns a reference to the Info RPC.
- `getNodeVersion` sends the request and retrieves the current version of Avalanche running on the node.

---

# Make sure it works

Once the code is complete and the file has been saved, refresh the page to see it update & display the current version.

![](../../../.gitbook/assets/pathways/avalanche/avalanche-connect.gif)

---

# Conclusion

Now that we have successfully connected to Avalanche node using DataHub, we are ready to move onto the next tutorial. We have also created the foundation for the next step, creating an account.


In this tutorial, we're going to connect with the Avalanche network

Connect To Avalanche

# Introduction

Unit testing is a software testing method where individual units or components of the software are tested. The purpose of unit tests is to validate that each unit of the software performs as designed.

In smart contract development, a comprehensive set of unit tests for each function are critical. Given that smart contracts are immutable once the bytecode is deployed and they can be responsible for managing rather large sums of money, writing good unit tests cannot be over-emphasized.

A thorough understanding of the smart contract being tested is very important to the effectiveness of the test. Steps must be taken to document what the smart contract does and how it does it. The next task is to map out each test to correspond with the contract’s functionality. In this tutorial, we will follow these outlined steps to write unit tests that cover the complete functionality of our contract.

# Prerequisites

This tutorial builds on a previously written tutorial on avalanche, so before we proceed any further make sure to complete - [Making an advanced e-Voting dApp on Avalanche Fuji network using Trufflesuite](https://learn.figment.io/tutorials/making-advanced-e-voting-dapp-avalanche-fuji-using-trufle).

# Breaking It Down

As pointed out above, a thorough understanding of the contract is required to write effective unit tests. Here, we'll break down our smart contract into separate units and map out each of our tests to correspond with the contract functions. If you followed the previous tutorial, you have a basic understanding of what the contract does and how. Let's go ahead and break down the contract to figure out what we need to test for.

In the `Election.sol` file from the Avalanche e-voting dApp we mentioned, there is a constructor and two functions, `addCandidate()` and `vote()`:

```javascript
constructor(string[] memory _nda, string[] memory _candidates) {
    require(_candidates.length > 0, "There should be atleast 1 candidate.");
    name = _nda[0];
    description = _nda[1];
    for (uint256 i = 0; i < _candidates.length; i++) {
        addCandidate(_candidates[i]);
    }
}

function addCandidate(string memory _name) private {
    candidates[candidatesCount] = Candidate(candidatesCount, _name, 0);
    candidatesCount++;
}

function vote(uint256 _candidate) public {
    require(!voters[msg.sender], "Voter has already Voted!");
    require(
        _candidate < candidatesCount && _candidate >= 0,
        "Invalid candidate to Vote!"
    );
    voters[msg.sender] = true;
    candidates[_candidate].voteCount++;
}
```

The `constructor(_nda, _candidates)` handles the instantiation of a new Election contract, it declares two arrays of strings named `_nda` and '\_candidates`respectively. The constructor is responsible for setting values for an Election such as`name`,`description`and`candidates\`. It is apparent from this that we need a unit test that validates that when instantiated, the contract variables are set to the same values passed to the constructor through the arguments.

The `addCandidate(_name)` function takes a `string` argument named `_name`, the name of the candidate. It will add a candidate to the `candidates mapping` variable and increment the `candidatesCount`. Because this function is called in the constructor, we can validate that it works as expected from the constructor test case.

The `vote(_candidate)` function takes a uint256 argument named '\_candidate`. This function is used to increment the total numbers of votes a candidate has and also adds the address of the voter to the`voters mapping`. Testing this will require the function to be called to validate the variables being set to the arguments as they are passed to the function. One more thing we need to do here is to test for the two`require\` statements to make sure the function fails according to the rule.

We can map out the above to the following test cases:

`contructor()` test case

```text
when the contract is instantiated  with (["US Election", "Presidential Election"], ["Satoshi", "Musk"])
  it should set name, description and candidates to the same values respectively

when the contract is instantiated  with (["US Election", "Presidential Election"], ["Satoshi", "Musk"])
  it should add the candidates to the candidates mapping
```

`vote()` test cases

```text
when the contract is instantiated  with (["US Election", "Presidential Election"], ["Satoshi", "Musk"])
  when vote() is called with (0)
    it should increment the voteCount of Satoshi

when the contract is instantiated  with (["US Election", "Presidential Election"], ["Satoshi", "Musk"])
  when vote() is called with (3)
    it should revert

when the contract is instantiated  with (["US Election", "Presidential Election"], ["Satoshi", "Musk"])
  when vote is called with address 0xsampleaddress
    when vote is called with address 0xsampleaddress
      it should revert
```

We have five test cases in total, two to validate that our constructor and addCandidate function work as expected, the other three to validate the functionality of the vote function.

# Writing the unit-tests in Solidity

Running `truffle init` in the previous article created the basic directories necessary for smart contract development. One of these directories is the `test` directory. We'll need to navigate to this directory as it is the specialized directory for test files:

```text
cd test
```

Create a new file:

{% tabs %}
{% tab title="Linux/macOS Terminal" %}
```text
touch TestElection.sol
```
{% endtab %}

{% tab title="Windows Terminal" %}
```
type NUL > TestElection.sol
```
{% endtab %}
{% endtabs %}

Open the TestElection.sol file with your favourite code editor and add the following lines:

```javascript
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "truffle/Assert.sol";
import "../contracts/Election.sol";

contract TestElection {

}
```

Truffle provides us with a default assertion library in `truffle/Assert.sol` which we imported in the fourth line of the code. You can find all available assertion functions in [Assert.sol](https://github.com/trufflesuite/truffle/blob/develop/packages/resolver/solidity/Assert.sol). We also added an import for the contract we are going to test against on line 5. The Assertion libraries are packages that contain functions we can use to verify our contract and that the expected results are correct.

On line 7, we declare the name of the test contract as `TestElection`. Preceding the name of the contract with `Test` lets the test runner $Truffle$ know this is going to be a test suite. Now we are ready to start writing our test cases. The first test case we are going to write is the constructor test case:

{% code title="test/TestElection.sol" %}
```javascript
function testConstructor() public {
    string[] memory nda = new string[](2);
    nda[0] = "US Election";
    nda[1] = "US presidential election";

    string[] memory candidates = new string[](2);
    candidates[0] = "Satoshi";
    candidates[1] = "Musk";

    Election election = new Election(nda, candidates);

    Assert.equal(election.name(), "US Election", "Name should be US Election");
    Assert.equal(election.description(), "US presidential election", "Name should be US presidential election");
}
```
{% endcode %}

Test cases in Solidity are functions with one or more assert statements. As the case mapping in the [Breaking It Down](unit-testing-in-solidity.md#breaking-it-down) section suggested, we instantiate a new Election contract with the necessary values and then use the Truffle Assertion library to validate that the `name` and `description` variables of the contract have the same values as those used to instantiate the contract.

The signature of the `Assert.equal()` function is `equal(string memory a, string memory b, string memory message) internal returns (bool result)`The function compares `a` and `b` returns true/false depending on the result of the comparison.

Before running the test, make sure to run the command `truffle develop` in a separate terminal window, as the Truffle tests will default to using a local development blockchain. Running the available test with `truffle test` should yield the following result:

```text
Using network 'development'.


Compiling your contracts...
===========================
✔ Fetching solc version list from solc-bin. Attempt #1
> Compiling ./contracts/Election.sol
> Compiling ./contracts/Migrations.sol
> Compiling ./test/TestElection.sol
✔ Fetching solc version list from solc-bin. Attempt #1
> Artifacts written to /var/folders/2z/5tb906js0c9_4y8q_y2hj4l40000gn/T/test--39459-k8UW13jOkERA
> Compiled successfully using:
   - solc: 0.8.6+commit.11564f7e.Emscripten.clang



  TestElection
✔ Fetching solc version list from solc-bin. Attempt #1
    ✓ testConstructor (134ms)

1 passing (34s)
```

This shows that our test passed as expected! We can be more certain now that our smart contract is going to function the way we intend it to. 

Our second and slightly more involved test case is for the private `addCandidate()` function:

```javascript
function testAddCandidate() public {
    string[] memory nda = new string[](2);
    nda[0] = "US Election";
    nda[1] = "US presidential election";

    string[] memory candidates = new string[](2);
    candidates[0] = "Satoshi";
    candidates[1] = "Musk";

    Election election = new Election(nda, candidates);
    uint256 firstCandidateId;
    string memory firstCandidateName;
    uint256 firstCandidateVoteCount;

    uint256 secondCandidateId;
    string memory secondCandidateName;
    uint256 secondCandidateVoteCount;

    (firstCandidateId, firstCandidateName, firstCandidateVoteCount) = election.candidates(0);
    (secondCandidateId, secondCandidateName, secondCandidateVoteCount) = election.candidates(1);

    Assert.equal(firstCandidateId, 0, "Candidate id should be '0'");
    Assert.equal(firstCandidateName, "Satoshi", "Candidate name should be 'Satoshi'");
    Assert.equal(firstCandidateVoteCount, 0, "Candidate voteCount should be '0'");
    Assert.equal(secondCandidateId, 1, "Candidate id should be '1'");
    Assert.equal(secondCandidateName, "Musk", "Candidate name should be 'Musk'");
    Assert.equal(secondCandidateVoteCount, 0, "Candidate voteCount should be '0'");
    Assert.equal(election.candidatesCount(), 2, "Candidate count be 2");
}
```

Here, we instantiate a new Election contract, get the details of the candidate from the contract and then test that they equal the values passed to the constructor.

Next, we'll look into how to test the `require()` call in a function. Our next test case is going to be for the second `require()` call in the `vote()` function. Since Solidity v0.4.17, a function type member was added to allow access to a [function selector](https://docs.soliditylang.org/en/v0.5.3/abi-spec.html#function-selector). This made exception testing in Solidity much easier than before:

```javascript
function testVoteFailIfVoted() public {
    string[] memory nda = new string[](2);
    nda[0] = "US Election";
    nda[1] = "US presidential election";

    string[] memory candidates = new string[](2);
    candidates[0] = "Satoshi";
    candidates[1] = "Musk";

    Election election = new Election(nda, candidates);
    election.vote(0);

    (, , uint256 voteCount) = election.candidates(0);

    Assert.equal(voteCount, 1, "'voteCount' should be 1");
    Assert.isTrue(election.voters(address(this)), "Should be true");

    bytes4 selector = election.vote.selector;
    bytes memory data = abi.encodeWithSelector(selector, uint256(0));

    (bool success, ) = address(election).call(data);

    Assert.isFalse(success, "Should be false");
}
```

What we are testing here is whether the `vote()` function fails as necessary when an address is used to vote twice. To do that, we instantiate the contract and call `vote()` for the same candidate twice. The second call must fail for this test to pass.

To test the exception:

* First get access to the function selector with `bytes4 selector = election.vote.selector;`, 
* Encode the selector with `bytes memory data = abi.encodeWithSelector(selector, uint256(0))`
* Then make an external call with the returned data from the second step with `(bool success, ) = address(election).call(data);`, lastly we validate that the transaction failed with `Assert.isFalse(success, "Should be false");`

# **Conclusion**

Congratulations! You've made it to the end of this short but informative tutorial on writing unit tests for smart contracts in Avalanche!

# Next Steps

Though this tutorial covers the basics involved in writing unit tests for smart contracts, nothing solidifies your knowledge of testing more than reading some existing code & coming up with test cases. It is also recommended to head over to the project repository on [Github](https://github.com/Segun-Ogundipe/advance-voting-test). The repo contains Javascript test files in case you're interested in writing test cases in Javascript.

# About the author

This tutorial was created by [Segun Ogundipe](https://www.linkedin.com/in/segun-ogundipe), You can get in touch with the author on [Figment Forum](https://community.figment.io/u/segun-ogundipe) and on [GitHub](https://github.com/segun-ogundipe)

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



How to write unit tests for Solidity smart contracts using Truffle's Assertions

Unit Testing in Solidity

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/platform/transfer-avax-between-x-chain-and-p-chain). 

# Introduction

AVAX tokens exist on the X-Chain, where they can be traded, on the P-Chain, where they can be provided as a stake when validating the Primary Network, and on the C-Chain, where they can be used in smart contracts or to pay for gas. Avalanche supports movement of AVAX between these chains, and in the future, Avalanche will support more generic atomic swaps between chains. In this tutorial, we’ll send AVAX tokens between the X-Chain and P-Chain.

# Requirements

You've created your [Avalanche DataHub](https://datahub.figment.io/sign_up?service=avalanche) account and are familiar with [Avalanche's architecture](https://docs.avax.network/learn/platform-overview).

In order to send AVAX, you need to have some AVAX! You can get real AVAX by buying it on an exchange, or you can get testnet AVAX from the [AVAX Test Faucet](https://faucet.avax-test.network), which is a free and easy way to get to play around with Avalanche.

## Transferring AVAX Using the Web Wallet

The easiest way to transfer AVAX between chains is to use [the Avalanche Wallet](https://wallet.avax.network/), which is a non-custodial and secure way to access and move AVAX.

The Avalanche Wallet source code can be found [here](https://github.com/ava-labs/avalanche-wallet).

### Step 1 - Open the Avalanche Wallet

![](../../../.gitbook/assets/wallet-x2p-01-login-1-%20%281%29.png)

Select **Access Wallet** to enter your wallet. To connect the wallet to a network other than the main Avalanche network, select **Mainnet** and choose the network to connect to.

### Step 2 - Log In to Your Wallet

You can access your wallet using the private key, mnemonic key phrase, keystore file or Ledger Nano S.

![](../../../.gitbook/assets/wallet-x2p-02-access%20%281%29.png)

After a successful login you will see your balance, assets portfolio and various other information.

### Step 3 - Go to the Cross Chain Tab

![](../../../.gitbook/assets/wallet-x2p-03-earn-1-.png)

Functionality for transferring tokens between chains is on the **Cross Chain** tab.

### Step 4 - Enter Amount to Transfer

You will be presented with a choice for **Source Chain** and **Destination Chain**. Select X-Chain and P-Chain, respectively. You will see your X and P balances, and an input field for entering the amount to transfer from source to destination chain.

![](../../../.gitbook/assets/wallet-x2p-05-x-p.png)

Enter the amount you wish to transfer from the X-Chain to the P-Chain.

### Step 5 - Confirm the Transaction

![](../../../.gitbook/assets/wallet-x2p-06-confirm.png)

Press **Confirm**, and then **Transfer** to initiate the transfer.

### Step 6 - Done!

A cross-chain transfer is a two step process: first a transaction to export the funds from the X-Chain, and another to import it to the P-Chain. The wallet will do both and show its the progress while doing so.

![](../../../.gitbook/assets/wallet-x2p-07-transfer.png)

That's it! You've transferred AVAX from the X-Chain to P-Chain! Now you can use them to validate or delegate on the Avalanche network.

### Transfer from P-Chain to X-Chain

To return the AVAX back to the X-Chain, you need to do the transfer in the opposite direction.

Swap the source and destination chains by selecting them from the **Source** and **Destination** drop-down menu. The rest of the process is the same: enter the amount, confirm and transfer.

## Transferring from the X-Chain to P-Chain with API Calls

If you're building an application on the Avalanche network, you may want to do the transfer programmatically as part of some broader functionality. You can do that by calling the appropriate APIs on an AvalancheGo node. The rest of the tutorial assumes you have access to an AvalancheGo node, AVAX tokens on the X-Chain, and user credentials [created](https://docs.avax.network/build/avalanchego-apis/keystore-api#keystorecreateuser) and stored in the node's keystore.

All the example API calls below assume the node is running locally $that is, listening on `127.0.0.1`$. The node can be connected to the main network, a test network or a local network. In each case, the API calls and responses should be the same, except for the address formats. The node need not be local; you can make calls to a node hosted elsewhere.

As you may have noticed while transferring AVAX using the Avalanche Wallet, a cross-chain transfer is a two transaction operation:

* Export AVAX from the X-Chain
* Import AVAX to the P-chain

### Step 1 - Export AVAX from the X-Chain

To export AVAX, call the X-Chain’s [`avm.exportAVAX`]() method.

Your call should look like this:

```cpp
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.exportAVAX",
    "params" :{
        "to":"P-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q",
        "destinationChain": "P",
        "amount": 5000000,
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username":"myUsername",
        "password":"myPassword"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

where `to` is the address of a P-Chain address your user controls and `changeAddr` is the address to send any change to. You can leave `changeAddr` blank; if you leave it blank, change will be returned to an address controlled by your user $see [here]() for instructions on creating a new P-Chain address$.

Note that you will pay a transaction fee for both the export and import operations. In this example, let’s assume the transaction fee is `.001` AVAX. Then, the above export actually consumes `.006` AVAX; `.005` goes to the P-Chain and `.001` is burned as a transaction fee.

Make sure that the amount that you’re sending exceeds the transaction fee. Otherwise, when you import AVAX on the P-Chain, it will consume the transaction fee, and you’ll end up with _less_ AVAX on the P-Chain.

The response should look like this:

```cpp
{
    "jsonrpc": "2.0",
    "result": {
        "txID": "MqEaeWc4rfkw9fhRMuMTN7KUTNpFmh9Fd7KSre1ZqTsTQG73h",
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
    },
    "id": 1
}
```

We can verify that this transaction was accepted by calling [`avm.getTxStatus`]():

```cpp
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "avm.getTxStatus",
    "params":{
        "txID":"MqEaeWc4rfkw9fhRMuMTN7KUTNpFmh9Fd7KSre1ZqTsTQG73h"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

Which shows our transaction is accepted:

```cpp
{
    "jsonrpc": "2.0",
    "result": {
        "status": "Accepted"
    },
    "id": 1
}
```

We can also call [`avm.getBalance`]() to check that the AVAX was deducted from an address held by our user:

```cpp
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-ADDRESSGOESHERE",
        "assetID":"AVAX"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The amount deducted is the exported amount $`.005` AVAX in this example$ plus the transaction fee. If your user controls multiple X-Chain addresses, AVAX may have been sent from any combination of them.

### Step 2 - Import AVAX to the P-Chain

Our transfer isn’t done just yet. We need to call the P-Chain’s [`platform.importAVAX`]() method to finish the transfer.

Your call should look like this:

```cpp
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.importAVAX",
    "params": {
        "to":"P-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q",
        "sourceChain":"X",
        "changeAddr":"P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u",
        "username":"myUsername",
        "password":"myPassword",
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P
```

This returns the transaction ID:

```cpp
{
    "jsonrpc": "2.0",
    "result": {
        "txID": "2sxo3ySETZ4xzXqAtgsUvZ5pdkqG4SML4c7Z7NoKLZcp77YNXC",
        "changeAddr":"P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u"
    },
    "id": 1
}
```

We can check that the transaction was accepted with:

```cpp
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getTxStatus",
    "params" :{
        "txID":"2sxo3ySETZ4xzXqAtgsUvZ5pdkqG4SML4c7Z7NoKLZcp77YNXC"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

It should be `Committed`, meaning the transfer is complete. We can also check the balance of the address with:

```cpp
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getBalance",
    "params":{
        "address":"P-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P
```

The response should look like this:

```cpp
{
    "jsonrpc": "2.0",
    "result": {
        "balance": "4000000",
        "utxoIDs": [
            {
                "txID": "2sxo3ySETZ4xzXqAtgsUvZ5pdkqG4SML4c7Z7NoKLZcp77YNXC",
                "outputIndex": 0
            }
        ]
    },
    "id": 1
}
```

Note that the balance we see is the amount exported from the X-Chain $`.004` AVAX$ less the transaction fee $`.001` AVAX in this example$. Now, we can use the AVAX held by this P-Chain address to provide a stake in order to validate the Primary Network.

## Transferring from the P-Chain to X-Chain programmatically

Now, let’s move AVAX from the P-Chain back to the X-Chain.

Same as before, this is also a two transaction operation:

* Export from the P-Chain
* Import to the X-Chain

### Step 1 - Export AVAX from the P-Chain

To do so, call [`platform.exportAVAX`]():

```cpp
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.exportAVAX",
    "params": {
        "to":"X-avax1fjn5rffqvny7uk3tjegjs6snwjs3hhgcpcxfax",
        "amount":3000000,
        "changeAddr":"P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u",
        "username":"myUsername",
        "password":"myPassword"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

where `to` is the X-Chain address the AVAX is being sent to.

This returns the transaction ID, and we can check that the transaction was committed with another call to [`platform.getTxStatus`](). Again, make sure that the amount you’re sending exceeds the transaction fee.

### Step 2 - Import AVAX to X-Chain

To finish our transfer from the P-Chain to the X-Chain, call [`avm.importAVAX`]():

```cpp
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.importAVAX",
    "params" :{
        "to":"X-avax1fjn5rffqvny7uk3tjegjs6snwjs3hhgcpcxfax",
        "sourceChain":"P",
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username":"myUsername",
        "password":"myPassword"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

Note that `to` is the same address specified in our call to [`platform.exportAVAX`]().

Just as before, we can call [`avm.getBalance`]() to verify the funds were received. The balance should have increased by `.003` AVAX minus the transaction fee.

## Wrapping Up

That’s it! Now, you can swap AVAX back and forth between the X-Chain and P-Chain, both by using the Avalanche Wallet, and by calling the appropriate API calls on an Avalanche node.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to transfer AVAX between chains

Transfer AVAX between the X-Chain and P-Chain

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/smart-contracts/using-truffle-with-the-avalanche-c-chain). 

# Introduction

[Truffle Suite](https://www.trufflesuite.com) is a toolkit for launching decentralized applications $dapps$ on the EVM. With Truffle you can write and compile smart contracts, build artifacts, run migrations and interact with deployed contracts. This tutorial illustrates how Truffle can be used with Avalanche's C-Chain, which is an instance of the EVM.

# Requirements

You've created an [Avalanche DataHub](https://datahub.figment.io/sign_up?service=avalanche) account and are familiar with [Avalanche's architecture](https://docs.avax.network/learn/platform-overview). You've also performed a cross-chain swap via the [Transfer AVAX Between X-Chain and C-Chain](https://docs.avax.network/build/tutorials/platform/transfer-avax-between-x-chain-and-c-chain) tutorial to get funds to your C-Chain address.

# Dependencies

* [Avash](https://github.com/ava-labs/avash) is a tool for running a local Avalanche network. It's similar to Truffle's [Ganache](https://www.trufflesuite.com/ganache).
* [NodeJS](https://nodejs.org/en) v8.9.4 or later.
* Truffle, which you can install with `npm install -g truffle`

# Start up a local Avalanche network

[Avash](https://github.com/ava-labs/avash) allows you to spin up private test network deployments with up to 15 AvalancheGo nodes out-of-the-box. Avash supports automation of regular tasks via lua scripts. This enables rapid testing against a wide variety of configurations. The first time you use avash you'll need to [install and build it](https://github.com/ava-labs/avash#quick-setup).

Start a local five node Avalanche network:

```javascript
cd /path/to/avash
// build Avash if you haven't done so
go build
// start Avash
./avash
// start a five node staking network
runscript scripts/five_node_staking.lua
```

A five node Avalanche network is running on your machine. When you want to exit Avash, run `exit`, but don't do that now, and don't close this terminal tab.

## Create truffle directory and install dependencies

Open a new terminal tab to so we can create a `truffle` directory and install some further dependencies.

First, navigate to the directory within which you intend to create your `truffle` working directory:

```javascript
cd /path/to/directory
```

Create and enter a new directory named `truffle`:

```javascript
mkdir truffle; cd truffle
```

Use `npm` to install [web3](https://web3js.readthedocs.io), which is a library through which we can talk to the EVM:

```text
npm install web3 -s
```

We'll use web3 to set an HTTP Provider which is how web3 will speak to the EVM. Lastly, create a boilerplace truffle project:

```text
truffle init
```

## Update truffle-config.js

One of the files created when you ran `truffle init` is `truffle-config.js`. Add the following to `truffle-config.js`.

```javascript
const Web3 = require('web3');
const protocol = "http";
const ip = "localhost";
const port = 9650;
module.exports = {
  networks: {
   development: {
     provider: function() {
      return new Web3.providers.HttpProvider(`${protocol}://${ip}:${port}/ext/bc/C/rpc`)
     },
     network_id: "*",
     gas: 3000000,
     gasPrice: 470000000000
   }
  }
};
```

Note that you can change the `protocol`, `ip` and `port` if you want to direct API calls to a different AvalancheGo node. Also note that we're setting the `gasPrice` and `gas` to the appropriate values for the Avalanche C-Chain.

## Add Storage.sol

In the `contracts` directory add a new file called `Storage.sol` and add the following block of code:

```javascript
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.8.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
}
```

`Storage` is a solidity smart contract which lets us write a number to the blockchain via a `store` function and then read the number back from the blockchain via a `retrieve` function.

## Add new migration

Create a new file in the `migrations` directory named `2_deploy_contracts.js`, and add the following block of code. This handles deploying the `Storage` smart contract to the blockchain.

```javascript
const Storage = artifacts.require("Storage");

module.exports = function (deployer) {
  deployer.deploy(Storage);
};
```

## Compile Contracts with Truffle

Any time you make a change to `Storage.sol` you need to run `truffle compile`.

```text
truffle compile
```

You should see:

```javascript
Compiling your contracts...
===========================
> Compiling ./contracts/Migrations.sol
> Compiling ./contracts/Storage.sol
> Artifacts written to /path/to/build/contracts
> Compiled successfully using:
   - solc: 0.5.16+commit.9c3226ce.Emscripten.clang
```

## Create, fund and unlock an account on the C-Chain

When deploying smart contracts to the C-Chain, truffle will default to the first available account provided by your C-Chain client as the `from` address used during migrations.

### Create an account

Truffle has a very useful [console](https://www.trufflesuite.com/docs/truffle/reference/truffle-commands#console) which we can use to interact with the blockchain and our contract. Open the console:

```javascript
truffle console --network development
```

Then, in the console, create the account:

```javascript
truffle(development)> let account = await web3.eth.personal.newAccount()
```

This returns:

```text
undefined
```

Print the account:

```javascript
truffle(development)> account
```

This prints the account:

```javascript
'0x090172CD36e9f4906Af17B2C36D662E69f162282'
```

### Unlock your account:

```javascript
truffle(development)> await web3.eth.personal.unlockAccount(account[0])
```

This returns:

```javascript
true
```

Exit the truffle console:

```javascript
truffle(development)> .exit
```

### Fund your account

Follow the steps in the [Transfer AVAX Between X-Chain and C-Chain]() tutorial to fund the newly created account. You'll need to send at least `135422040` nAVAX to the account to cover the cost of contract deployments.

## Run Migrations

Now everything is in place to run migrations and deploy the `Storage` contract:

```javascript
truffle migrate --network development
```

You should see:

```javascript
Compiling your contracts...
===========================
> Everything is up to date, there is nothing to compile.

Migrations dry-run (simulation)
===============================
> Network name:    'development-fork'
> Network id:      1
> Block gas limit: 99804786 (0x5f2e672)


1_initial_migration.js
======================

   Deploying 'Migrations'
   ----------------------
   > block number:        4
   > block timestamp:     1607734632
   > account:             0x34Cb796d4D6A3e7F41c4465C65b9056Fe2D3B8fD
   > balance:             1000.91683679
   > gas used:            176943 (0x2b32f)
   > gas price:           470 gwei
   > value sent:          0 ETH
   > total cost:          0.08316321 ETH

   -------------------------------------
   > Total cost:          0.08316321 ETH

2_deploy_contracts.js
=====================

   Deploying 'Storage'
   -------------------
   > block number:        6
   > block timestamp:     1607734633
   > account:             0x34Cb796d4D6A3e7F41c4465C65b9056Fe2D3B8fD
   > balance:             1000.8587791
   > gas used:            96189 (0x177bd)
   > gas price:           470 gwei
   > value sent:          0 ETH
   > total cost:          0.04520883 ETH

   -------------------------------------
   > Total cost:          0.04520883 ETH

Summary
=======
> Total deployments:   2
> Final cost:          0.13542204 ETH
```

If you didn't create an account on the C-Chain you'll see this error:

```javascript
Error: Expected parameter 'from' not passed to function.
```

If you didn't fund the account, you'll see this error:

```javascript
Error:  *** Deployment Failed ***

"Migrations" could not deploy due to insufficient funds
   * Account:  0x090172CD36e9f4906Af17B2C36D662E69f162282
   * Balance:  0 wei
   * Message:  sender doesn't have enough funds to send tx. The upfront cost is: 1410000000000000000 and the sender's account only has: 0
   * Try:
      + Using an adequately funded account
```

If you didn't unlock the account, you'll see this error:

```javascript
Error:  *** Deployment Failed ***

"Migrations" -- Returned error: authentication needed: password or unlock.
```

## Interacting with your contract

Now the `Storage` contract has been deployed. Let's write a number to the blockchain and then read it back. Open the truffle console again:

```javascript
truffle console --network development
```

Get an instance of the deployed `Storage` contract:

```javascript
truffle(development)> let instance = await Storage.deployed()
```

This returns:

```javascript
undefined
```

### Writing a number to the blockchain

Now that you have an instance of the `Storage` contract, call it's `store` method and pass in a number to write to the blockchain.

```javascript
truffle(development)> instance.store(1234)
```

If you see this error:

```javascript
Error: Returned error: authentication needed: password or unlock
```

Then run this again: `node web3_script.js`

You should see something like:

```javascript
{
  tx: '0x10afbc5e0b9fa0c1ef1d9ec3cdd673e7947bd8760b22b8cdfe08f27f3a93ef1e',
  receipt: {
    blockHash: '0x8bacbce7c9d835db524bb856288e3a73a6afbe49ab34abd8cd8826db0240eb21',
    blockNumber: 9,
    contractAddress: null,
    cumulativeGasUsed: 26458,
    from: '0x34cb796d4d6a3e7f41c4465c65b9056fe2d3b8fd',
    gasUsed: 26458,
    logs: [],
    logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
    status: true,
    to: '0x0d507b0467baef742f9cc0e671eddbdf6df41d33',
    transactionHash: '0x10afbc5e0b9fa0c1ef1d9ec3cdd673e7947bd8760b22b8cdfe08f27f3a93ef1e',
    transactionIndex: 0,
    rawLogs: []
  },
  logs: []
}
```

### Reading a number from the blockhain

To read the number from the blockchain, call the `retrieve` method of the `Storage` contract instance.

```javascript
truffle(development)> let i = await instance.retrieve()
```

This should return:

```javascript
undefined
```

The result of the call to `retrieve` is a `BN` $big number$. Call its `.toNumber` method to see the value:

```javascript
truffle(development)> i.toNumber()
```

You should see the number you stored.

```javascript
1234
```

# Summary

Now you have the tools you need to launch a local Avalanche network, create a truffle project, as well as create, compile, deploy and interact with Solidity contracts.  
  
If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to use Truffle with the C-Chain

Using Truffle with the Avalanche C-Chain

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/smart-digital-assets/creating-a-variable-cap-asset). 

# Introduction

This tutorial illustrates how to create a variable-cap, fungible asset. No units of the asset exist when the asset is initialized, but more units of the asset may be minted. On asset creation we specify which sets of addresses may mint more units.

You may be wondering why we specify _sets_ of addresses that can mint more units of the asset rather than a single address.

The first reason is security. If only one address can mint more of the asset, and the private key for that address is lost, no more units can ever be minted. Similarly, if only one address can mint more of the asset, nothing stops the holder of that address from unilaterally minting as much as they want.

The second reason is flexibility. It’s nice to be able to encode logic like, “Alice can unilaterally mint more units of this asset, or 2 of Dinesh, Ellin, and Jamie can together mint more.”

Suppose that we want to issue an asset that represents shares of a corporation. No shares exist to start with, but more shares may be created later. Let’s create such an asset.

### Assumptions 

We assume that you’re already familiar with [**DataHub**](https://datahub.figment.io/sign_up?service=avalanche) and connecting to the Avalanche services.

## Create the Asset

Our asset will exist on the X-Chain, so to create our asset we’ll call `avm.createVariableCapAsset`, which is a method of the [X-Chain’s API](https://docs.figment.io/network-documentation/avalanche/rpc-and-rest-api/).

The signature for this method is:

```javascript
avm.createVariableCapAsset({
    name: string,
    symbol: string,
    denomination: int,
    minterSets []{
        minters: []string,
        threshold: int
    },
    from: []string,
    changeAddr: string,
    username: string,
    password: string
}) ->
{
    assetID: string,
    changeAddr: string,
}
```

#### Parameters <a id="parameters"></a>

* `name` is a human-readable name for our asset. Not necessarily unique. Between 0 and 128 characters.
* `symbol` is a shorthand symbol for this asset. Between 0 and 4 characters. Not necessarily unique. May be omitted.
* `denomination` determines how balances of this asset are displayed by user interfaces. If denomination is 0, 100 units of this asset are displayed as 100. If denomination is 1, 100 units of this asset are displayed as 10.0. If denomination is 2, 100 units of this asset are displays as .100, etc.
* `minterSets` is a list where each element specifies that `threshold` of the addresses in `minters` may together mint more of the asset by signing a minting transaction.
* Performing a transaction on the X-Chain require a transaction fee paid in AVAX. `username` and `password` denote the user paying the fee.
* `from` are the addresses that you want to use for this operation. If omitted, uses any of your addresses as needed.
* `changeAddr` is the address any change will be sent to. If omitted, change is sent to one of the addresses controlled by the user.

#### Response <a id="response"></a>

* `assetID` is the ID of the new asset.
* `changeAddr` in the result is the address where any change was sent.

Later in this example we’ll mint more shares, so be sure to replace at least 2 addresses in the second minter set with addresses your user controls.

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.createVariableCapAsset",
    "params" :{
        "name":"Corp. Shares",
        "symbol":"CS",
        "minterSets":[
            {
                "minters": [
                    "X-avax1ghstjukrtw8935lryqtnh643xe9a94u3tc75c7"
                ],
                "threshold": 1
            },
            {
                "minters": [
                    "X-avax1k4nr26c80jaquzm9369j5a4shmwcjn0vmemcjz",
                    "X-avax1yell3e4nln0m39cfpdhgqprsd87jkh4qnakklx",
                    "X-avax1ztkzsrjnkn0cek5ryvhqswdtcg23nhge3nnr5e"
                ],
                "threshold": 2
            }
        ],
        "from":["X-avax1s65kep4smpr9cnf6uh9cuuud4ndm2z4jguj3gp"],
        "changeAddr":"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response should look like this:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "assetID":"i1EqsthjiFTxunrj8WD2xFSrQ5p2siEKQacmCCB5qBFVqfSL2",
        "changeAddr":"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8"
    }
}
```

## Mint the Asset

Right now 0 shares exist. Let’s mint 10M shares.

#### Create the Unsigned Transaction <a id="create-the-unsigned-transaction"></a>

We’ll use `avm.mint` to mint the shares.

* `amount` is the number of shares that will be created.
* `assetID` is the ID of the asset we’re creating more of.
* `to` is the address that will receive the newly minted shares. Replace `to` with an address your user controls so that later you’ll be able to send some of the newly minted shares.
* `username` must be a user that holds keys giving it permission to mint more of this asset. That is, it controls at least _threshold_ keys for one of the minter sets we specified above.

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.mint",
    "params" :{
        "amount":10000000,
        "assetID":"i1EqsthjiFTxunrj8WD2xFSrQ5p2siEKQacmCCB5qBFVqfSL2",
        "to":"X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv",
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response contains the transaction’s ID:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "txID":"E1gqPbkziu8AutqccRa9ioPWyEF3Vd7eMjDJ3UshjQPpLoREZ",
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8"
    }
}
```

We can check the status of the transaction we’ve just sent to the network using `avm.getTxStatus`:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.getTxStatus",
    "params" :{
        "txID":"E1gqPbkziu8AutqccRa9ioPWyEF3Vd7eMjDJ3UshjQPpLoREZ"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

This should give:

```javascript
{
    "jsonrpc": "2.0",
    "result": {
        "status": "Accepted"
    },
    "id": 1
}
```

## Trade the Asset

#### Check a Balance <a id="check-a-balance"></a>

All 10M shares are controlled by the `to` address we specified in `mint`. To verify this we’ll use `avm.getBalance`:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv",
        "assetID":"i1EqsthjiFTxunrj8WD2xFSrQ5p2siEKQacmCCB5qBFVqfSL2"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response confirms that our asset creation was successful, and that the expected address holds all 10,000,000 shares:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "balance":10000000
    }
}
```

#### Send the Asset <a id="send-the-asset"></a>

Let’s send 100 shares to another address by using `avm.send`. To do so:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.send",
    "params" :{
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE",
        "assetID" :"i1EqsthjiFTxunrj8WD2xFSrQ5p2siEKQacmCCB5qBFVqfSL2",
        "amount"  :100,
        "to"      :"X-avax1qwnlpknmdkkl22rhmad0dcn80wfasp2y3yg3x0"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

Let’s check the balances of the `to` address:

```javascript
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-avax1qwnlpknmdkkl22rhmad0dcn80wfasp2y3yg3x0",
        "assetID":"i1EqsthjiFTxunrj8WD2xFSrQ5p2siEKQacmCCB5qBFVqfSL2"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response should be:

```javascript
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "balance":100
    }
}
```

## Wrapping up

In this tutorial, we:

* Used `createVariableCapAsset` to create a variable-cap asset that represents shares.
* Used `mint` to mint more units of an asset.
* Used `getBalance` to check address balances.
* Used `send` to transfer shares.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to create a variable-cap asset on Avalanche

Creating A Variable-Cap Asset

# Introduction

Continuing with the theme of token transfers, in this tutorial we are going to learn how to programmatically transfer ERC-20 tokens from the Avalanche C-Chain to a Metamask wallet.

# Prerequisites

* [Create an Avalanche wallet](https://wallet.avax.network/create)
* [Fund your Avalanche wallet with the FUJI Faucet](https://docs.avax.network/build/tutorials/platform/fuji-workflow#get-a-drip-from-the-fuji-faucet)
* [Transfer FUJI Avax tokens from X-Chain to C-Chain](https://docs.avax.network/build/tutorials/platform/transfer-avax-between-x-chain-and-c-chain)
* Having an integrated development environment, such as [Visual Studio Code](https://code.visualstudio.com/download)
* Familiarity with the use of a DEX such as Pangolin and [the concept of token swap](https://www.youtube.com/watch?v=kNQp4t03lOQ)

# Requirements

* [NodeJS](https://nodejs.org/en)
* [Ethers](https://docs.ethers.io/v5/) , which you can install with `npm install ethers`
* Install [Metamask extension](https://metamask.io/download.html) in your browser.
* [Configure your Metamask to add Avalanche FUJI testnet](https://docs.avax.network/build/tutorials/smart-contracts/deploy-a-smart-contract-on-avalanche-using-remix-and-metamask#step-1-setting-up-metamask)  

# Getting started

For the purpose of this tutorial, I have created an ERC-20 token named AVAXDATAHUB and created an AVAXDATAHUB - AVAX liquidity pool on [Pangolin](https://app.pangolin.exchange/#/swap) on the Fuji testnet. Pangolin is a decentralized exchange built on Avalanche and it is compatible with the Fuji testnet as well, for testing purposes. 

We will go on Pangolin and swap AVAX for some AVAXDATAHUB tokens. The token contract address is `0x6089f3b5f97eCDc8d31f317C7b442580E4258ef7`. 

Go on [Pangolin](https://app.pangolin.exchange/#/swap) and swap AVAX on your Metamask for some AVAXDATAHUB, as outlined in the image below.

![AVAXDATAHUB](https://i.imgur.com/CCUNU5z.png) 

After the swap, go back to Metamask, click on "Add Token" and type in the contract address as shown in the image below. Without manually adding the AVAXDATAHUB token, it will not show up on your Metamask.

![AVAXDATAHUB_IN_METAMASK](https://i.imgur.com/K8YgMrY.png)

The AVAXDATAHUB tokens you got from Pangolin should now show up on your Metamask wallet, as shown below (8.979 AVAXDATAHUB tokens).

![FROM_PANGOLIN](https://i.imgur.com/o9JE1kJ.png)

For the sake of the tutorial, let's send some of those AVAXDATAHUB tokens from Metamask to your Avalanche private wallet. Refer to the image below if you are confused about how to do this.

![send_to_avax_wallet](https://i.imgur.com/NC7HDqh.png)

In the image above, it is shown that 4 AVAXDATAHUB tokens have been sent to the C-Chain of the Avalanche wallet. 

However, when logging into your Avalanche wallet, you will not be able to see the tokens yet. 

![not_shown](https://i.imgur.com/LwPWIlo.png)

In order to view those tokens, you have to add the token contract address.

Click on "Add Token" below the coin list of the wallet and type in the AVAXDATAHUB contract address, then the rest of the information should automatically be loaded, as shown in the image below.

![contract_address_typed](https://i.imgur.com/r8aglQ9.png)

Then, you should be able to see the tokens show up on your list, as shown in the image below.

![avaxdatahub_added](https://i.imgur.com/VlDuDn8.png)

What we have done up to this point has taught you that any ERC-20 token can be stored on the C-Chain of your Avalanche wallet. 

## Transfer of ERC-20 tokens from C-Chain to ETH address

We are going to create a new file called `ERC20_fromC_to_ETH_address.js` in the root directory of your project. Once you create a .js file under the specified name, we will type in the following blocks of code in. 

First, we need to import the `ethers` library to interact with the Avalanche C chain

```javascript
const { ethers } = require('ethers');
```

The mnemonic key from your AVAX wallet needs to go between the quotation marks below. This is later used to extract the C chain wallet address.

```javascript
const mnemonic = "";
```

The code below is pointing to AVAX mainnet.

```javascript
const provider = new ethers.providers.JsonRpcProvider('https://api.avax-test.network/ext/bc/C/rpc');
```

With the mnemonic phrase provided earlier, we can extract the corresponding ETH wallet private key. With this, we can unlock the Avalanche C-Chain wallet and sign transactions, which is accomplished with the code below.

```javascript
const walletMnemonic = new ethers.Wallet.fromMnemonic(mnemonic);
const pvtKey  = walletMnemonic.privateKey;
const wallet = new ethers.Wallet(pvtKey, provider);
```
Transferring tokens from one wallet to another is a transaction. In order to perform a transaction, certain information needs to be provided. The token address $also known as contract address$ of the ERC-20 token $AVAXDATAHUB in this case$ needs to be provided. So, we are going to store the contract address and the ticker below. The token ticker is not needed, but we are adding it for our own use. A lot of the token contract addresses for Avalanche can be found [here](https://github.com/pangolindex/tokenlists/blob/main/aeb.tokenlist.json).

```javascript
const tknAddr = "0x6089f3b5f97eCDc8d31f317C7b442580E4258ef7";  
const token_name = "AVAXDATAHUB";
```
Logically, we also need provide the destination address. Put the destination address between the quotation marks.

```javascript
const toAddr = "";
```

Another piece needed for issuing a transaction is what's called the ABI. The Contract Application Binary Interface $ABI$ is the standard way to interact with contracts in the Ethereum ecosystem. The format of the ABI is provided [here](https://docs.ethers.io/v5/getting-started/#getting-started--contracts).


```javascript
const tknAbi = [
  // Some details about the token
  "function name() view returns (string)",
  "function symbol() view returns (string)",

  // Get the account balance
  "function balanceOf(address) view returns (uint)",

  // Send some of your tokens to someone else
  "function transfer(address to, uint amount)",

  // An event triggered whenever anyone transfers to someone else
  "event Transfer(address indexed from, address indexed to, uint amount)"
  ];
```

Although it is not necessary to print the AVAXDATAHUB balance of the destination wallet address to perform a transfer, we will show here how to read the balance of a certain token. 

```javascript
const getBalance = async () => {
  // Create Contract object connected to provider
  const tknContract = new ethers.Contract(tknAddr, tknAbi, provider);

  // Get balance as BigNumber and convert to Number
  const balanceBigNum = await tknContract.balanceOf(toAddr);
  const balanceNum = Number(ethers.utils.formatEther(balanceBigNum));

  // Set precision and convert to string
  const precision = 4;
  const balanceStr = balanceNum.toFixed(precision).toString();

  return balanceStr;
}
```

Now, we are going to define the `sendToken` function, which will execute a transfer of 1 AVAXDATAHUB token from the C-Chain of the Avalanche wallet to the ETH destination address.

```javascript
const sendToken = async () => {
  if (provider === null || wallet === null) {
    console.error("Encountered null object, unable to send token.");
    return;
  } 

  // Create Contract object connected to wallet
  const tknContract = new ethers.Contract(tknAddr, tknAbi, wallet);

  // Specify amount to send (e.g. 1 ERC20 token)
  const amt = ethers.utils.parseEther("1.0");

  // Send amount to destination
  const tx = tknContract.transfer(toAddr, amt);

  return tx;
}
```

Now that we have the functions to read the balance and execute a transfer, we are ready to implement them. The code below reads the balance before and after the transfer of 1 AVAXDATAHUB token. 

```javascript
getBalance()
  .then(initBalance => {
    console.log("Initial destination balance: ", initBalance);

    // Send ERC20 token from AVAX wallet C-Chain to ETH address
    sendToken()
      .then(_tx => {
        console.log("Transfer successful!");
      })
      .catch(console.error);
  })
.catch(console.error);
```

At this point, you have gone through the entire script.

The finished script should look as follows:

```javascript
const { ethers } = require('ethers');
const mnemonic = "";
const provider = new ethers.providers.JsonRpcProvider('https://api.avax-test.network/ext/bc/C/rpc');

const walletMnemonic = new ethers.Wallet.fromMnemonic(mnemonic);
const pvtKey  = walletMnemonic.privateKey;
const wallet = new ethers.Wallet(pvtKey, provider);

const tknAddr = "0x6089f3b5f97eCDc8d31f317C7b442580E4258ef7";  
const token_name = "AVAXDATAHUB";
const toAddr = "";

const tknAbi = [
  // Some details about the token
  "function name() view returns (string)",
  "function symbol() view returns (string)",

  // Get the account balance
  "function balanceOf(address) view returns (uint)",

  // Send some of your tokens to someone else
  "function transfer(address to, uint amount)",

  // An event triggered whenever anyone transfers to someone else
  "event Transfer(address indexed from, address indexed to, uint amount)"
  ];

const getBalance = async () => {
  // Create Contract object connected to provider
  const tknContract = new ethers.Contract(tknAddr, tknAbi, provider);

  // Get balance as BigNumber and convert to Number
  const balanceBigNum = await tknContract.balanceOf(toAddr);
  const balanceNum = Number(ethers.utils.formatEther(balanceBigNum));

  // Set precision and convert to string
  const precision = 4;
  const balanceStr = balanceNum.toFixed(precision).toString();

  return balanceStr;
}

const sendToken = async () => {
  if (provider === null || wallet === null) {
    console.error("Encountered null object, unable to send token.");
    return;
  } 

  // Create Contract object connected to wallet
  const tknContract = new ethers.Contract(tknAddr, tknAbi, wallet);

  // Specify amount to send (e.g. 1 ERC20 token)
  const amt = ethers.utils.parseEther("1.0");

  // Send amount to destination
  const tx = tknContract.transfer(toAddr, amt);

  return tx;
}

getBalance()
  .then(initBalance => {
    console.log("Initial destination balance: ", initBalance);

    // Send ERC20 token from AVAX wallet C-Chain to ETH address
    sendToken()
      .then(_tx => {
        console.log("Transfer successful!");
      })
      .catch(console.error);
  })
.catch(console.error);
```

To run the script `ERC20_fromC_to_ETH_address.js`, type `node ERC20_fromC_to_ETH_address.js` and run it in your terminal (node before the file name is the way to invoke the NodeJS runtime environment).

The output of the script in the terminal should look similar to what is shown below.

![example_output](https://i.imgur.com/i0ysO5Q.png)

You can confirm the result by looking at the change of the balance on Metamask as well.

As you can see in the image below, the balance did change from 4.97 to 5.97.

![metamask_balance](https://i.imgur.com/CTIA5eu.png)

# Troubleshooting

## Transaction Failure

If you have enough AVAX on the C-Chain but not enough AVAXDATAHUB token (or any ERC20 token that you intend to transfer), you may end up getting an error in the terminal. Such an error message would be as shown below.

![example](https://i.imgur.com/eB5ERwh.png)

Although the error message says something along the lines of gas cost estimate issues, the issue is not having sufficient balance of AVAXDATAHUB. Make sure that you have enough ERC20 token balance on the C-Chain of your AVAX wallet.

Conversely, if you have enough AVAXDATAHUB balance, but not enough AVAX token to pay for the transaction, the same error message is produced. Similarily, make sure that you have sufficient AVAX balance to pay for the transaction. 

# Conclusion

This tutorial has taught you how to transfer ERC-20 tokens from the C-Chain to a Metamask wallet. Note that the C-Chain uses the Ethereum Virtual Machine and is compatible with all of the key Ethereum tools.

# About the Author

This tutorial was created by [Seongwoo Oh](https://github.com/blackwidoq). He is a student and an Avalanche novice.

Learn how to transfer ERC-20 tokens from C-Chain to Ethereum

Transfer ERC-20 tokens from C-Chain to an Ethereum address

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/platform/create-a-new-blockchain). 

# Introduction

One of the core features of the Avalanche network is the ability to create new blockchains. Avalanche currently supports creation of new instances of the AVM $the Virtual Machine the X-Chain runs$ and the Timestamp VM.

In this tutorial we’ll create a new instance of the AVM.

# Create the Subnet

Every blockchain is validated by a [Subnet.](https://docs.avax.network/learn/platform-overview#subnets) Before you can create a blockchain, you’ll need a Subnet to validate it.

[This tutorial](https://learn.figment.io/tutorials/create-a-subnet) will guide you through creating a Subnet.

You can also use a Subnet that already exists, if you have a sufficient number of its control keys.

# Add Validators to the Subnet

The Subnet needs validators in it to, well, validate blockchains.

Make sure the Subnet that will validate your blockchain has at least `snow-sample-size` validators in it. $Recall that `snow-sample-size` is one of the [command-line arguments](https://docs.avax.network/build/references/command-line-interface/) when starting a node. Its default value is 20.$

[This tutorial](https://docs.avax.network/build/tutorials/platform/add-a-validator) will guide you through adding validators to the Subnet, if that’s necessary.

# Create the Genesis Data

Each blockchain has some genesis state when it’s created. Each Virtual Machine has a static API method named `buildGenesis` that takes in a JSON representation of a blockchain’s genesis state and returns the byte representation of that state. $This isn’t true for some VMs, like the Platform VM, because we disallow creation of new instances.$

The [AVM’s documentation](https://docs.figment.io/network-documentation/avalanche/rpc-and-rest-api/) specifies that the argument to `avm.buildGenesis` should look like this:

```json
{
"genesisData":
    {
        "assetAlias1": {               // Each object defines an asset
            "name": "human readable name",
            "symbol":"AVAL",           // Symbol is between 0 and 4 characters
            "initialState": {
                "fixedCap" : [         // Choose the asset type.
                    {                  // Can be "fixedCap", "variableCap"
                        "amount":1000, // At genesis, address A has
                        "address":"A"  // 1000 units of asset
                    },
                    {
                        "amount":5000, // At genesis, address B has
                        "address":"B"  // 1000 units of asset
                    },
                    ...                // Can have many initial holders
                ]
            }
        },
        "assetAliasCanBeAnythingUnique": { // Asset alias can be used in place of assetID in calls
            "name": "human readable name", // names need not be unique
            "symbol": "AVAL",              // symbols need not be unique
            "initialState": {
                "variableCap" : [          // No units of the asset exist at genesis
                    {
                        "minters": [       // The signature of A or B can mint more of
                            "A",           // the asset.
                            "B"
                        ],
                        "threshold":1
                    },
                    {
                        "minters": [       // The signatures of 2 of A, B and C can mint
                            "A",           // more of the asset
                            "B",
                            "C"
                        ],
                        "threshold":2
                    },
                    ...                    // Can have many minter sets
                ]
            }
        },
        ...                                // Can list more assets
    }
}
```

To create the byte representation of this genesis state, call `avm.buildGenesis`. Your call should look like the one below. Note that this call is made to the AVM’s static API endpoint, `/ext/vm/avm`.

```
curl -X POST --data '{
    "jsonrpc": "2.0",
    "id"     : 1,
    "method" : "avm.buildGenesis",
    "params" : {
        "genesisData": {
            "asset1": {
                "name": "myFixedCapAsset",
                "symbol": "MFCA",
                "initialState": {
                    "fixedCap" : [
                        {
                            "amount":100000,
                            "address": "8UeduLccQuSmYiY3fGQEyotM9uXxoHoQQ"
                        },
                        {
                            "amount":100000,
                            "address": "AgVkHvvDShLumJrzXzkwuHa7rYpewj9Kg"
                        },
                        {
                            "amount":50000,
                            "address": "AwBDGsUwNdXgVc8XG2E8A8dL3bkoVbkL9"
                        },
                        {
                            "amount":50000,
                            "address": "AATN8YjgmFjC2jQRq45sEeGcBFXNYPcM8"
                        }
                    ]
                }
            },
            "asset2": {
                "name": "myVarCapAsset",
                "symbol":"MVCA",
                "initialState": {
                    "variableCap" : [
                        {
                            "minters": [
                                "AATN8YjgmFjC2jQRq45sEeGcBFXNYPcM8",
                                "FNqMDYafoDVYQ2o4a7Zd9maJAxcUEieQb"
                            ],
                            "threshold":1
                        },
                        {
                            "minters": [
                                "JJSiKQfha9Z2TiMxBZ8XdW9F6KFw8aKS4",
                                "7jJHY1vZL6AAbCFb97KMLY8nqMQVyd5JG",
                                "58pM5cEf1wMSncPdCwtQ8tbHs2xdMA4eo"
                            ],
                            "threshold":2
                        }
                    ]
                }
            }
        }
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/vm/avm
```

This returns the byte representation of your blockchain’s genesis state:

```json
{
    "jsonrpc": "2.0",
    "result": {
        "bytes": "111TNWzUtHKoSvxohjyfEwE2X228ZDGBngZ4mdMUVMnVnjtnawW1b1zbAhzyAM1v6d7ECNj6DXsT7qDmhSEf3DWgXRj7ECwBX36ZXFc9tWVB2qHURoUfdDvFsBeSRqatCmj76eZQMGZDgBFRNijRhPNKUap7bCeKpHDtuCZc4YpPkd4mR84dLL2AL1b4K46eirWKMaFVjA5btYS4DnyUx5cLpAq3d35kEdNdU5zH3rTU18S4TxYV8voMPcLCTZ3h4zRsM5jW1cUzjWVvKg7uYS2oR9qXRFcgy1gwNTFZGstySuvSF7MZeZF4zSdNgC4rbY9H94RVhqe8rW7MXqMSZB6vBTB2BpgF6tNFehmYxEXwjaKRrimX91utvZe9YjgGbDr8XHsXCnXXg4ZDCjapCy4HmmRUtUoAduGNBdGVMiwE9WvVbpMFFcNfgDXGz9NiatgSnkxQALTHvGXXm8bn4CoLFzKnAtq3KwiWqHmV3GjFYeUm3m8Zee9VDfZAvDsha51acxfto1htstxYu66DWpT36YT18WSbxibZcKXa7gZrrsCwyzid8CCWw79DbaLCUiq9u47VqofG1kgxwuuyHb8NVnTgRTkQASSbj232fyG7YeX4mAvZY7a7K7yfSyzJaXdUdR7aLeCdLP6mbFDqUMrN6YEkU2X8d4Ck3T"
    },
    "id": 1
}
```

# Create the blockchain

Now let’s create the new blockchain. To do so, we call `platform.createBlockchain`. Your call should look like the one below. You have to change `subnetID` to the subnet that will validate your blockchain, and supply a `username` that controls a sufficient number of the Subnet’s control keys. As a reminder, you can find out what a Subnet’s threshold and control keys are by calling `platform.getSubnet`.

```
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.createBlockchain",
    "params" : {
        "subnetID": "KL1e8io1Zi2kr8cTXxvi321pAzfQuUa8tmBfadqpf9K2dc2TT",
        "vmID":"avm",
        "name":"My new AVM",
        "genesisData": "111TNWzUtHKoSvxohjyfEwE2X228ZDGBngZ4mdMUVMnVnjtnawW1b1zbAhzyAM1v6d7ECNj6DXsT7qDmhSEf3DWgXRj7ECwBX36ZXFc9tWVB2qHURoUfdDvFsBeSRqatCmj76eZQMGZDgBFRNijRhPNKUap7bCeKpHDtuCZc4YpPkd4mR84dLL2AL1b4K46eirWKMaFVjA5btYS4DnyUx5cLpAq3d35kEdNdU5zH3rTU18S4TxYV8voMPcLCTZ3h4zRsM5jW1cUzjWVvKg7uYS2oR9qXRFcgy1gwNTFZGstySuvSF7MZeZF4zSdNgC4rbY9H94RVhqe8rW7MXqMSZB6vBTB2BpgF6tNFehmYxEXwjaKRrimX91utvZe9YjgGbDr8XHsXCnXXg4ZDCjapCy4HmmRUtUoAduGNBdGVMiwE9WvVbpMFFcNfgDXGz9NiatgSnkxQALTHvGXXm8bn4CoLFzKnAtq3KwiWqHmV3GjFYeUm3m8Zee9VDfZAvDsha51acxfto1htstxYu66DWpT36YT18WSbxibZcKXa7gZrrsCwyzid8CCWw79DbaLCUiq9u47VqofG1kgxwuuyHb8NVnTgRTkQASSbj232fyG7YeX4mAvZY7a7K7yfSyzJaXdUdR7aLeCdLP6mbFDqUMrN6YEkU2X8d4Ck3T",
        "username":"USERNAME",
        "password":"PASSWORD"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

The response contains the transaction ID:

```json
{
    "jsonrpc": "2.0",
    "result": {
        "txID": "xAd5n5PQFV6RRo8UgH54Gf5tJs8oQdctQS2ygp5F2dKZDckYH",
        "changeAddr": "P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u"
    },
    "id": 1
}
```

# Verify success

After a few seconds, the transaction to create our blockchain should have been accepted and the blockchain should exist $assuming the request was well-formed, etc.$

To check, call `platform.getBlockchains`. This returns a list of all blockchains that exist.

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"platform.getBlockchains",
    "params" :{}
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

The response confirms that the blockchain was created:

```json
{
    "jsonrpc": "2.0",
    "result": {
        "blockchains": [
            {
                "id": "AXerNQX7voY2AABaRdTAyXcawBURBR6thPRJp43LtPpZZi6Qz",
                "name": "X-Chain",
                "subnetID": "11111111111111111111111111111111LpoYY",
                "vmID": "jvYyfQTxGMJLuGWa55kdP2p2zSUYsQ5Raupu4TW34ZAUBAbtq"
            },
            {
                "id": "tZGm6RCkeGpVETUTp11DW3UYFZmm69zfqxchpHrSF7wgy8rmw",
                "name": "C-Chain",
                "subnetID": "11111111111111111111111111111111LpoYY",
                "vmID": "mgj786NP7uDwBCcq6YwThhaN8FLyybkCa4zBWTQbNgmK6k9A6"
            },
            {
                "id": "CqhF97NNugqYLiGaQJ2xckfmkEr8uNeGG5TQbyGcgnZ5ahQwa",
                "name": "Simple DAG Payments",
                "subnetID": "11111111111111111111111111111111LpoYY",
                "vmID": "sqjdyTKUSrQs1YmKDTUbdUhdstSdtRTGRbUn8sqK8B6pkZkz1"
            },
            {
                "id": "VcqKNBJsYanhVFxGyQE5CyNVYxL3ZFD7cnKptKWeVikJKQkjv",
                "name": "Simple Chain Payments",
                "subnetID": "11111111111111111111111111111111LpoYY",
                "vmID": "sqjchUjzDqDfBPGjfQq2tXW1UCwZTyvzAWHsNzF2cb1eVHt6w"
            },
            {
                "id": "2SMYrx4Dj6QqCEA3WjnUTYEFSnpqVTwyV3GPNgQqQZbBbFgoJX",
                "name": "Simple Timestamp Server",
                "subnetID": "11111111111111111111111111111111LpoYY",
                "vmID": "tGas3T58KzdjLHhBDMnH2TvrddhqTji5iZAMZ3RXs2NLpSnhH"
            },
            {
                "id": "zpFTwJwzPh3b9N6Ahccy4fXdJFHJJdhGah5z731J6ZspcYKpK",
                "name": "My new AVM",
                "subnetID": "KL1e8io1Zi2kr8cTXxvi321pAzfQuUa8tmBfadqpf9K2dc2TT",
                "vmID": "jvYyfQTxGMJLuGWa55kdP2p2zSUYsQ5Raupu4TW34ZAUBAbtq"
            }
        ]
    },
    "id": 1
}
```

# Interact with the new blockchain

You can interact with this new instance of the AVM almost the same way you’d interact with the X-Chain. There are two small differences:

* The API endpoint of your blockchain is `127.0.0.1:9650/ext/bc/zpFTwJwzPh3b9N6Ahccy4fXdJFHJJdhGah5z731J6ZspcYKpK`.
* Addresses are prepended with `zpFTwJwzPh3b9N6Ahccy4fXdJFHJJdhGah5z731J6ZspcYKpK-` rather than `X-`.

In the genesis data we specified that address `8UeduLccQuSmYiY3fGQEyotM9uXxoHoQQ` has 100,000 units of the asset with alias `asset1`. Let’s verify that:

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"zpFTwJwzPh3b9N6Ahccy4fXdJFHJJdhGah5z731J6ZspcYKpK-8UeduLccQuSmYiY3fGQEyotM9uXxoHoQQ",
        "assetID":"asset1"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/zpFTwJwzPh3b9N6Ahccy4fXdJFHJJdhGah5z731J6ZspcYKpK
```

```json
{
    "jsonrpc": "2.0",
    "result": {
        "balance": "100000"
    },
    "id": 1
}
```

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!


Learn how to create a new Blockchain on Avalanche

Create a New Blockchain

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/smart-digital-assets/wallet-nft-studio). 

# Non-Fungible Tokens on Avalanche

Besides the native AVAX token, [Avalanche platform](https://docs.avax.network/build/tutorials/platform) natively supports the creation of other types of digital assets: fixed-cap assets, variable-cap assets, and non-fungible tokens $NFTs$.

As opposed to regular tokens, which are interchangeable $fungible$, meaning that each one is the same, each non-fungible token is unique on the network, with a distinct ID making it different from any other. This enables many use cases that would be impossible with interchangeable tokens, like proof of ownership of a unique asset.

# NFT Studio on Avalanche Wallet

To make experimenting with the creation and exchange of NFTs easier, we have built **NFT Studio** into the [Avalanche Wallet](https://wallet.avax.network/), where you can use it to create NFTs as assets that we call Collectibles. Collectibles can be generic NFTs with a picture and a description, or custom NFTs with payloads containing JSON, custom URL, or UTF-8 data. You can create them using a simple point and click interface, enabling you to go from an idea of sending NFTs to your friends within minutes. No technical knowledge required.

To access the **NFT Studio**, log into your Avalanche Wallet, and on the left side select **Studio**:

![](../../../.gitbook/assets/nft-studio-01-select.png)

This will open the NFT Studio. There you have two options: **New Family**, for the creation of a new family of NFTs, and **Mint Collectible** for creating new assets in existing families. We need to create our first family of NFTs, so click **New Family**.

# Create NFT Family

There you will be asked to enter the name of your collectible family, as well as a symbol $ticker$. Names do not have to be unique.

![](../../../.gitbook/assets/nft-studio-02-family.png)

Besides the name and the ticker, you will need to enter **Number of Groups**, that is, how many distinct collectibles will the newly created family hold. Choose carefully, because once created, the parameters of the collectible family cannot be changed.

When you decided upon the name, ticker, and number of groups, press **Create** to actually create the collectible family. The transaction fee will be deducted from your wallet's balance. When the family is created, you will see the transaction ID $TxID$, as well as parameters for the family. You can use the TxID to look up the transaction in [the explorer](https://explorer.avax.network/), but it is not necessary to write it down.

Press **Back to Studio** to return, and we're ready to create our first collectibles. Press **Mint Collectible**.

# Mint NFTs

After pressing **Mint Collectible** you will be presented with a list of all the Collectible families that still have Collectible groups that have not been created yet.

![](../../../.gitbook/assets/nft-studio-03-select-family.png)

Select the family we have just created. You will be presented with a form to fill out with the parameters of the new collectible:

![](../../../.gitbook/assets/nft-studio-04-mint.png)

By default, a **Generic** type of collectible will be selected. That is an NFT that has a **Title**, **URL** for the image, and a **Description**. Enter the required data, as well as the **Quantity**, which will determine how many copies of the collectible will be created, and therefore, how many of them you will be able to send. As before, enter the data carefully, you won't be able to change anything once collectibles are minted. You will see a preview of the data where you can check how your collectible will look like.

If you would like to have something else besides a picture collectible, select **Custom**.

![](../../../.gitbook/assets/nft-studio-05-custom.png)

A custom collectible can contain an **UTF-8** encoded string, an **URL**, or a **JSON** payload. Size of the data cannot exceed 1024 characters.

After you enter and check the data, press **Mint** to create the collectible. Transaction fees will be deducted from your wallet, and a newly created collectible will be placed in your wallet.

# See your collectibles

An overview of your collectibles is always visible in the top of the screen, along with your balances.

![](../../../.gitbook/assets/nft-studio-06-overview.png)

To see your collectibles in more detail, select **Portfolio** from the left-hand side menu. You will be presented with a screen showing all of your assets, with tokens selected by default. Change the selection to **Collectibles** by clicking the corresponding tab.

![](../../../.gitbook/assets/nft-studio-07-collectibles.png)

For each Generic collectible, a picture will be shown, along with the title, and the number indicating how many copies of the collectible are in your portfolio. Hovering over the collectible with your pointer will show the detailed description:

![](../../../.gitbook/assets/nft-studio-08-detail.png)

If you select a collectible by clicking on it, you will see which group it belongs to, its quantity, along with the **Send** button.

# Send NFTs

To send your collectible to someone, either click the **Send** button on the selected collectible in the Portfolio, or navigate to **Send** tab on the left-hand side menu, and click **Add Collectible**:

![](../../../.gitbook/assets/nft-studio-09-send.png)

You will be presented with a menu to select a collectible you wish to send.

![](../../../.gitbook/assets/nft-studio-10-multiple.png)

You can send multiple collectibles in a single transaction. Clicking the label on the collectible will let you edit the number of copies you wish to send. You can send multiple families and collectible types in a single transaction.

When you have entered the destination address, and optionally entered the memo text, press **Confirm** to initiate the transaction.

![](../../../.gitbook/assets/nft-studio-11-send-transaction-1-.png)

After pressing **Send Transaction** it will be published on the network, and the transaction fee will be deducted from your balance. Collectibles will be deposited into the destination address shortly after.

# Summary

Now, you should know how to create NFT families, mint NFT groups, and send them to other addresses. Have fun with it! If you would like to know the technical background of how NFTs work on the Avalanche network or would like to build products using NFTs, please check out the [NFT tutorial](https://learn.figment.io/tutorials/creating-an-nft-part-1). 

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to create NFTs with the Avalanche Wallet

Create NFTs with the Avalanche Wallet

# Introduction

[Hardhat](https://hardhat.org) is a suite of tools that together provides us with a development environment that assists developers to easily manage and automate common tasks around building smart contracts and dApps. Hardhat can be used to compile, deploy, test, and debug smart contracts. It is very similar to [Truffle](https://www.trufflesuite.com/) in this regard.

What differentiates Hardhat from Truffle is that it provides developers with a seamless experience for working with and debugging complex Solidity smart contracts with the help of plugins that offer powerful extensibility.

In this tutorial, we will learn how to use Hardhat with the Avalanche C-Chain. The C-Chain is an instance of the EVM $[Ethereum Virtual Machine](https://ethereum.org/en/developers/docs/evm/)$. Being an instance of the EVM makes the Avalanche C-Chain very attractive as it can run the smart contract projects already written in Solidity.

# Prerequisites

Please make sure that you have completed the tutorials:

* [Avash Installation](https://learn.figment.io/tutorials/local-avalanche-network-using-avash)

# Requirements

For the smooth completion of this tutorial, we need the following software to be already present on your system:

* [NodeJS](https://nodejs.org/) $12.x+$

# Creating a Hardhat project

The first step is to create a directory for your project where you will initialize our new Hardhat project. You can do this using the following command:

```
mkdir avalanche-hardhat-tutorial && cd avalanche-hardhat-tutorial
npm init -y
```

You should see a newly created directory named `avalanche-hardhat-tutorial` with a file `package.json` inside it:

```json
{
  "name": "avalanche-hardhat-tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}
```

Now we go on to install Hardhat as one of our project dependencies with the following command:

```bash
npm install --save-dev hardhat
```

After the installation is done, type the following command to make the current directory a Hardhat project:

```bash
npx hardhat
```

You should be greeted with such a prompt by Hardhat:

```text
888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

Welcome to Hardhat v2.2.1

? What do you want to do? …
Create a sample project
▸ Create an empty hardhat.config.js
Quit
```

Choose to create an empty `hardhat.config.js` and there you have it, your current directory is now a Hardhat project!

# Adding Avash network configuration to Hardhat

Now, in order for our Hardhat project to communicate with our local Avalanche network bootstrapped by Avash, we need to provide Hardhat with appropriate network configuration. For that, add the following properties to the module.exports block of `hardhat.config.js`:

```javascript
defaultNetwork: "avash",
networks: {
  avash: {
    url: 'http://localhost:9650/ext/bc/C/rpc',
    gasPrice: 225000000000,
    chainId: 43112,
    accounts: [
      "0x56289e99c94b6912bfc12adc093c9b51124f0dc54ac7a766b2bc5ccf558d8027",
      "0x7b4198529994b0dc604278c99d153cfd069d594753d471171a1d102a10438e07",
      "0x15614556be13730e9e8d6eacc1603143e7b96987429df8726384c2ec4502ef6e",
      "0x31b571bf6894a248831ff937bb49f7754509fe93bbd2517c9c73c4144c0e97dc",
      "0x6934bef917e01692b789da754a0eae31a8536eb465e7bff752ea291dad88c675",
      "0xe700bdbdbc279b808b1ec45f8c2370e4616d3a02c336e68d85d4668e08f53cff",
      "0xbbc2865b76ba28016bc2255c7504d000e046ae01934b04c694592a6276988630",
      "0xcdbfd34f687ced8c6968854f8a99ae47712c4f4183b78dcc4a903d1bfe8cbf60",
      "0x86f78c5416151fe3546dece84fda4b4b1e36089f2dbc48496faf3a950f16157c",
      "0x750839e9dbbd2a0910efe40f50b2f3b2f2f59f5580bb4b83bd8c1201cf9a010a"
    ]
  },
},
```

* The network url we provide points to the localhost and the RPC endpoint, this is the test network launched by Avash.
* The gas price of `225000000000` is the current gas price of the network - anything less and the transactions will fail, stating that the transaction is under-priced.
* `43112` is the id for the chain created by Avash. This value is hardcoded in Avash.
* The list of accounts we are providing above are randomly generated addresses on the network. When it comes to Avash, unlike on Avalanche mainnet and the Fuji testnet, these developer addresses come loaded with lots AVAX and so we don't need to fund them from a faucet. The balances are reset every time a new Avash network is created.

# Adding and compiling a smart contract

Hardhat looks for contracts to compile within the `contracts` directory. So let's go ahead and create this directory:

```bash
mkdir contracts
```

In the `contracts` directory we just created, create a new file called `Storage.sol` and add the following solidity code to it:

```javascript
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.8.0;

/**
* @title Storage
* @dev Store & retrieve the value in a variable
*/
contract Storage {

  uint256 number;

  /**
  * @dev Store value in variable
  * @param num value to store
  */
  function store(uint256 num) public {
    number = num;
  }

  /**
  * @dev Return value
  * @return value of 'number'
  */
  function retrieve() public view returns (uint256){
    return number;
  }
}
```

`Storage` is a solidity smart contract that lets us write a number to the blockchain via the `store` function and then read the number back from the blockchain via the `retrieve` function.

To compile the Storage.sol smart contract we just added to our project, use the following command:

```bash
npx hardhat compile
```

After the successful execution of the command, the smart contract should now be compiled!

# Using the Hardhat console

For the rest of the tutorial, we're going to use the Hardhat console to deploy and interact with our smart contract. To successfully use the Hardhat console for our purposes, we need to install a couple of Hardhat plugins, namely [`hardhat-ethers`](https://www.npmjs.com/package/@nomiclabs/hardhat-ethers) and [`hardhat-waffle`](https://www.npmjs.com/package/@nomiclabs/hardhat-waffle). Install them using the following commands:

```
npm install --save-dev @nomiclabs/hardhat-ethers 'ethers@^5.0.0'
npm install --save-dev @nomiclabs/hardhat-waffle 'ethereum-waffle@^3.0.0' @nomiclabs/hardhat-ethers 'ethers@^5.0.0'
```

After these plugins are installed, we need to tell Hardhat to use them by requiring `hardhat-waffle` at the beginning of the Hardhat configuration file we created earlier:

```javascript
require("@nomiclabs/hardhat-waffle");
```

Now, the file should look like this:

```javascript
require("@nomiclabs/hardhat-waffle");

/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
  solidity: "0.7.3",
  defaultNetwork: "avash",
    networks: {
      avash: {
        url: 'http://localhost:9650/ext/bc/C/rpc',
        gasPrice: 225000000000,
        chainId: 43112,
        accounts: [
          "0x56289e99c94b6912bfc12adc093c9b51124f0dc54ac7a766b2bc5ccf558d8027",
          "0x7b4198529994b0dc604278c99d153cfd069d594753d471171a1d102a10438e07",
          "0x15614556be13730e9e8d6eacc1603143e7b96987429df8726384c2ec4502ef6e",
          "0x31b571bf6894a248831ff937bb49f7754509fe93bbd2517c9c73c4144c0e97dc",
          "0x6934bef917e01692b789da754a0eae31a8536eb465e7bff752ea291dad88c675",
          "0xe700bdbdbc279b808b1ec45f8c2370e4616d3a02c336e68d85d4668e08f53cff",
          "0xbbc2865b76ba28016bc2255c7504d000e046ae01934b04c694592a6276988630",
          "0xcdbfd34f687ced8c6968854f8a99ae47712c4f4183b78dcc4a903d1bfe8cbf60",
          "0x86f78c5416151fe3546dece84fda4b4b1e36089f2dbc48496faf3a950f16157c",
          "0x750839e9dbbd2a0910efe40f50b2f3b2f2f59f5580bb4b83bd8c1201cf9a010a"
        ]
    },
  },
};
```

We're now ready to deploy our smart contract and interact with it!

# Deploying smart contracts using Hardhat console

To deploy our smart contract and to interact with it, we're gonna be using an interactive JavaScript console provided by Hardhat, which is called Hardhat console. Hardhat console is geared more towards providing us with quick local development and testing environment than writing scripts to do the same.

> Ensure that the local Avalanche network outlined in the `Setup a local Avalanche network using Avash` tutorial is running properly. Follow that other tutorial to completion, however, do not exit the Avash console after running the Lua script. Leave it running & in a separate terminal window, follow these instructions.

To fire up the Hardhat console, we use:

```text
npx hardhat console
```

We'll be greeted with an interactive console environment that looks like this:

```text
Welcome to Node.js v14.16.1.
Type ".help" for more information.
>
```

Now we go on and type in the following snippets of code to deploy and interact with our Storage smart contract. After you input each line of code, press "Enter" to execute the same.

In order to get an instance of the `Storage.sol` contract using Hardhat, we use the `getContractFactory` function from `hre`, the Hardhat Runtime Environment :

```javascript
const Storage = await hre.ethers.getContractFactory("Storage");
```

This will return `undefined` !

Here, `undefined` does not mean that the instruction we executed has failed. Instead, it's `undefined` because we stored the return value into the Storage constant and there's nothing to be printed out into the console. We could verify that the command executed successfully by logging the contents of the Storage constant with :

```javascript
console.log(Storage)
```

> What you see below is a Javascript representation of the compiled smart contract - you don't need to understand everything you see in the logged output. We print it out to demonstrate that the instruction was executed successfully.

![](../../../.gitbook/assets/storage-console-log.png)

Now we go on to deploy the Storage contract we just retrieved, using:

```javascript
const storage = await Storage.deploy();
```

Again, this returns `undefined` !

Before we start interacting with the smart contract, we need to wait for the contract to be deployed successfully using :

```javascript
await storage.deployed();
```

This will return a lot of output, which is the internal representation of the smart contract in JavaScript.  
 The following example has been truncated:

```javascript
Contract {
  interface: Interface {
    fragments: [ [FunctionFragment], [FunctionFragment] ],
    _abiCoder: AbiCoder { coerceFunc: null },
    functions: {
      'retrieve()': [FunctionFragment],
      'store(uint256)': [FunctionFragment]
    },
    errors: {},
    events: {},
    structs: {},
    deploy: ConstructorFragment {
      name: null,
      type: 'constructor',
      inputs: [],
      payable: false,
      stateMutability: 'nonpayable',
      gas: null,
      _isFragment: true
    },
    _isInterface: true
  },
```

# Interacting with smart contracts using Hardhat console

To store our favourite magical number into the blockchain, we call the store function of the deployed contract:

```javascript
await storage.store(333);
```

This outputs the Javascript representation of the transaction details:

```javascript
{
  hash: '0xaae491304254fce18fc3ff77f5891feef69035d05eb93c6b542823f948426ac4',
  type: 0,
  accessList: null,
  blockHash: null,
  blockNumber: null,
  transactionIndex: null,
  confirmations: 0,
  from: '0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC',
  gasPrice: BigNumber { _hex: '0x34630b8a00', _isBigNumber: true },
  gasLimit: BigNumber { _hex: '0xaa26', _isBigNumber: true },
  to: '0x4Ac1d98D9cEF99EC6546dEd4Bd550b0b287aaD6D',
  value: BigNumber { _hex: '0x00', _isBigNumber: true },
  nonce: 5,
  data: '0x6057361d000000000000000000000000000000000000000000000000000000000000014d',
  r: '0x2be3e63b57eb1dd045361317e5380af910527a03b8e00cbde6226350d908d698',
  s: '0x6c45b5adabfd6cabde520a8f4a649b639f59e1e9fe3234713bb8152515bcf9d0',
  v: 86259,
  creates: null,
  chainId: 43112,
  wait: [Function (anonymous)]
}
```

Now, we're all set to read the number we just stored into our contract and print it out, using:

```javascript
let i = await storage.retrieve();
console.log(i.toNumber());
```

Run the code again and you should now see the output `333` printed to the console.

# Conclusion

In this tutorial, we've successfully created a new Hardhat project. Within the Hardhat project, we added a new smart contract, then compiled it using Hardhat. Finally, we deployed the contract and interacted with it using the Hardhat console.

Congratulations on making it to the end of this tutorial!

> “No great thing is created suddenly, any more than a bunch of grapes or a fig. If you tell me that you desire a fig, I answer that there must be time. Let it first blossom, then bear fruit, then ripen.”
>
> -- Epictetus

So, keep learning and keep building and I'm sure you're on your way to building something great! Good luck!

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can join [**our community**](https://discord.gg/fszyM7K) today!


Learn how to use Hardhat with the Avalanche C-Chain

Using Hardhat with the Avalanche C-Chain

Learn how to create a decentralized exchange on Avalanche.

Create a Decentralized Exchange (DEX) on Avalanche

Since Avalanche operates on 3 chains (X/P/C), it allows users to transfer tokens in each direction.

AVAX tokens exist on the X-Chain, where they can be traded, on the P-Chain, where they can be provided as a stake when validating the Primary Network, and on the C-Chain, where they can be used in smart contracts or to pay for gas fees. Avalanche supports movement of AVAX between these chains. We'll be concentrating our efforts on X->C swaps, with C-Chain being used for smart contract deployments.

Inter-chain transfers are performed via a 2-step process:

- Create the X-Chain export transaction
- Create the C-Chain import transaction -> (this tutorial)

Here we will focus on the second part, the **C-Chain import transaction**.

---

# Challenge

{% hint style="tip" %}
In `pages/api/avalanche/import.ts`, implement the function and try to import the AVAX sent in the previous tutorial to C-Chain. You must replace any instances of `undefined` with working code to accomplish this.
{% endhint %}

**Take a few minutes to figure this out**

```typescript
//...
  try {
    const {secret, network} = req.body;
    const client = getAvalancheClient(network);

    // Initialize chain components
    const [ xChain   , cChain    ] = [ client.XChain()            , client.CChain()             ];
    const [ xKeychain, cKeychain ] = [ xChain.keyChain()          , cChain.keyChain()           ];
    const [ xKeypair , cKeypair  ] = [ xKeychain.importKey(secret), cKeychain.importKey(secret) ];
    const [ cAddress ] = [ cKeypair.getAddressString() ];

    // Get the real ID for X-Chain
    const xChainId = undefined;

    // Fetch UTXOs (unspent transaction outputs)
    const { utxos } = await cChain.getUTXOs(cAddress, xChainId);

    // Derive Eth-like address from the private key
    const binTools = BinTools.getInstance();
    const keyBuff = binTools.cb58Decode(secret.split('-')[1]);
    const ethAddr = Address.fromPrivateKey(
      Buffer.from(keyBuff.toString('hex'), 'hex'),
    ).toString();
    console.log("Ethereum-style address: ", ethAddr);

    // Generate an unsigned import transaction
    const importTx = await cChain.buildImportTx(undefined);

    // Sign and send import transaction
    const hash = await cChain.issueTx(importTx.sign(cKeychain));

    res.status(200).json(hash)
  }
//...
```

**Need some help?** Check out these links

- [**Code examples**](https://github.com/ava-labs/avalanchejs/tree/master/examples/avm)
- [**Manage X-Chain Keys**](https://docs.avax.network/build/tools/avalanchejs/manage-x-chain-keys)

{% hint style="info" %}
You can [**join us on Discord**](https://discord.gg/fszyM7K), if you have questions or want help completing the tutorial.
{% endhint %}

Still not sure how to do this? No problem! The solution is below so you don't get stuck.

---

# Solution

```typescript
// solution
//...
  try {
    const {secret, network} = req.body;
    const client = getAvalancheClient(network);

    // Initialize chain components
    const [ xChain   , cChain    ] = [ client.XChain()            , client.CChain()             ];
    const [ xKeychain, cKeychain ] = [ xChain.keyChain()          , cChain.keyChain()           ];
    const [ xKeypair , cKeypair  ] = [ xKeychain.importKey(secret), cKeychain.importKey(secret) ];
    const [ cAddress ] = [ cKeypair.getAddressString() ];

    // Get the real ID for X-Chain
    const xChainId = await client.Info().getBlockchainID("X");

    // Fetch UTXOs (i.e unspent transaction outputs)
    const { utxos } = await cChain.getUTXOs(cAddress, xChainId);

    // Derive Eth-like address from the private key
    const binTools = BinTools.getInstance();
    const keyBuff = binTools.cb58Decode(secret.split('-')[1]);
    const ethAddr = Address.fromPrivateKey(
      Buffer.from(keyBuff.toString('hex'), 'hex'),
    ).toString();
    console.log("Ethereum-style address: ", ethAddr);

    // Generate an unsigned import transaction
    const importTx = await cChain.buildImportTx(
        utxos,
        ethAddr,
        [cAddress],
        xChainId,
        [cAddress]
    )

    // Sign and send import transaction
    const hash = await cChain.issueTx(importTx.sign(cKeychain));

    res.status(200).json(hash);
  }
//...
```

**What happened in the code above?**

- First, we need to build our C-Chain keypair. This works exactly the same way for X-Chain.
- Next, we determine the chainId.
- Next, we fetch the latest `UTXOS`.
- Next, as we're working on an EVM compatible blockchain (C-Chain understands Solidity smart contracts), we need to deduce the Ethereum-style address from the private key.
- Next, we build our transaction the same way as for a simple transfer:
  - There is no amount, as we're importing an already existing amount.
  - The destination address is in Ethereum format as we're working on an EVM compatible chain.
- Finally, we sign and send the transaction and return the transaction hash.

---

# Make sure it works

Once the code is complete and the file is saved, Next.js will rebuild the API route. Click on **Import 0.05 AVAX** and you should see the balance displayed on the page:

![](../../../.gitbook/assets/pathways/avalanche/avalanche-import.gif)

---

# Conclusion

Congratulations, you've made it this far and successfully completed an AVAX transfer from the X-Chain to the C-Chain. The same approach works in reverse (C-Chain -> X-Chain), or for any other inter-chain transfers (X-Chain -> P-Chain or P-Chain -> C-Chain for example).

The Avalanche team has put together a [good list of examples](https://github.com/ava-labs/avalanchejs/tree/master/examples/avm), be sure to check them out if you need a more advanced look at the AvalancheJS library.

Ready for more? No problem! While the basic Pathway is complete at this point, you are more than welcome to explore other [Avalanche tutorials](https://learn.figment.io/protocols/avalanche).

If you had any difficulties following this tutorial or simply want to discuss Avalanche with other developers you can join [our Discord](https://discord.gg/fszyM7K) or head over to our [community forums](https://community.figment.io).


In this tutorial, we'll learn how to import your AVAX token from another chain

Import Token from X-Chain to C-Chain

# Introduction

NFT is an interesting term nowadays, in more technical terms NFT collectible is called ERC721 token. Please refer to the below link to learn more about [ERC-721 token](https://ethereum.org/en/developers/docs/standards/tokens/erc-721/). It is a form of “art” that can be a picture, tweet, audio, etc in a broader perspective. A non-fungible token $NFT$ is a unit of data on a digital ledger called blockchain, where each NFT represents something unique item, that can’t be interchanged. This enables many use cases that would be impossible with interchangeable tokens, like utility, proof of ownership, and a unique asset transaction history.

# Prerequisites

In preparation for the tutorial, we will need to have some images on hand for testing the upload to Avalanche wallet. Please refer to the documentation for more information on the Avalanche wallet,[here](https://docs.avax.network/).

# Create NFTs

## Create New Wallet

Go to [Avalanche Wallet](https://wallet.avax.network/) and click on create a new wallet.

![](../../../.gitbook/assets/create-new-wallet.png)

## Generate Key Phrase

Next, click the "Generate Key Phrase" button, which will display a list of 24 words that you will need to save in a secure location. This list of words is used to access your account, so do not share it with anyone!

![](../../../.gitbook/assets/generate-new-key.png)

![](../../../.gitbook/assets/your-key-phrase.png)

## Verify And Access Wallet

Once you have saved or written down the keywords in a secure location, click the checkbox to enable the "Access Wallet" button. Clicking this button displays the Verify Mnemonic modal window. Complete the phrase to verify that you have the correct words.

![](../../../.gitbook/assets/verify-key-phrase.png)

Now, you can access your account. Click access and you will be directed to the account window.

![](../../../.gitbook/assets/access-wallet.png)

In your avalanche wallet window, you will see- Balance, Assets, Wallet Address, Transaction & Transaction History $as shown in image$.

![](../../../.gitbook/assets/avalanche-wallet.png)

On the left sidebar are the other activity tabs: Send, Earn, Cross-chain, Studio, Activity, Manage keys, and Advanced.

## NFT Studio on Avalanche Wallet

To make experimenting with the creation and exchange of NFTs easier, the [Avalanche Wallet](https://wallet.avax.network/)! has a built-in NFT Studio, where you can create NFTs as assets that Avalanche calls Collectibles. Collectibles can be generic NFTs with a picture and a description, or custom NFTs with payloads containing JSON, custom URL, or UTF-8 data. You can create them using a simple point and click interface, enabling you to go from concept to sending NFTs to your friends within minutes. No technical knowledge is required.

To access the **NFT Studio**, log into your Avalanche Wallet, and on the left side select **Studio**:

This will open the NFT Studio. There you have two options: **New Family**, for the creation of a new family of NFTs, and **Mint Collectible** for creating new assets in existing families. We need to create our first family of NFTs, so click **New Family**.

# Create an NFT Family

There you will be asked to enter the name of your collectible family, as well as a symbol $ticker$. Names do not have to be unique.

## Mint NFTs

Before minting, Go to the Studio tab. Below the heading "Collectibles" are two sections, "new family" and "mint collectibles".

![](../../../.gitbook/assets/avalanche-studio.PNG)

Click on Studio, where you can create a new family of collectibles if you have not yet done so.

![](../../../.gitbook/assets/create-new-family-studio.png)

You can use the TxID to look up the transaction on the Avalanche block explorer. Besides the name and the ticker, you will need to enter a **Number of Groups**, which is how many distinct collectibles the newly created family will hold. Choose carefully, because once created the parameters of the collectible family cannot be changed.

To create a new mint, provide a name, a code, and several groups. Note that a fee of 0.1 AVAX will be deducted from your balance to mint. For testing, you can use the Fuji testnet. You will need to switch networks in the Avalanche wallet UI. Once you are on the Fuji testnet, it is possible to get AVAX for testing from the official faucet.

To give it a test, follow below steps:

![](../../../.gitbook/assets/change-network-to-fuji.png)

Go to the AVAX faucet at [here](https://faucet.avax-test.network/)!

![](../../../.gitbook/assets/avax-faucet-testnet.PNG)

Paste the address of your wallet $which you can copy from the Avalanche wallet UI$ into the text input and pass the CAPTCHA to receive 2 AVAX tokens.

Select the family we have just created. You will be presented with a form to fill out with the parameters of the new collectible:

![](../../../.gitbook/assets/mint-collectibles.png)

Press **Back to Studio** to return, and we're ready to create our first collectibles. Press **Mint Collectible**. but if minting is not supported, then you need to create a new collectible family as shown below.

![](../../../.gitbook/assets/wallet-avax-network.png)

That is an NFT that has a Title, URL for the image, and a Description. Enter the required data, and the Quantity, which will determine how many copies of the collectible will be created. As before, enter the data carefully - you won't be able to change anything once collectibles are minted. You will see a preview of the data where you can check how your collectible will look.

If you would like to have something else besides a picture collectible, select **Custom**.

![](../../../.gitbook/assets/nft-studio-05-custom.png)

A custom collectible can contain an **UTF-8** encoded string, an **URL**, or a **JSON** payload. The size of the data cannot exceed 1024 characters.

After you enter and check the data, press **Mint** to create the collectible. Transaction fees will be deducted from your wallet, and a newly created collectible will be placed in your wallet.

# See your collectibles

An overview of your collectibles is always visible at the top of the screen, along with your balances.

![](../../../.gitbook/assets/avalanche-balance.png)

To see your collectibles in more detail, select **Portfolio** from the left-hand side menu. You will be presented with a screen showing all of your assets, with tokens selected by default. Change the selection to **Collectibles** by clicking the corresponding tab.

![](../../../.gitbook/assets/collectible-coin.png)

For each Generic collectible, a picture will be shown, along with the title, and the number indicating how many copies of the collectible are in your portfolio. Hovering over the collectible with your pointer will show the detailed description:

If you select a collectible by clicking on it, you will see which group it belongs to, its quantity, along with the **Send** button.

# Transfer NFTs

To send your collectible to someone, either click the **Send** button on the selected collectible in the Portfolio, or navigate to the **Send** tab on the left-hand side menu, and click **Add Collectible**:

![](../../../.gitbook/assets/send-nft-different-address.png)

You will be presented with a menu to select a collectible you wish to send.

![](../../../.gitbook/assets/pikachu-coin-wallet-address.png)

You can send multiple collectibles in a single transaction. Clicking the label on the collectible will let you edit the number of copies you wish to send. You can send multiple families and collectible types in a single transaction.

![](../../../.gitbook/assets/send-nft-to-different-wallet.png)

When you have entered the destination address, and optionally entered the memo text, press **Confirm** to initiate the transaction.

![](../../../.gitbook/assets/transaction-history.png)

After pressing **Send Transaction** it will be published on the network, and the transaction fee will be deducted from your balance. Collectibles will be deposited into the destination address shortly after.

# Summary

Now, you should know how to create families of collectible NFTs, mint NFTs in groups, and send them to other addresses. Have fun with it! If you would like to know the technical background of how NFTs work on the Avalanche network or would like to build products using NFTs, please check out this [Avalanche NFT tutorial](https://learn.figment.io/tutorials/creating-an-nft-part-1)!.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://community.figment.io/) or [**Join our discord channel**](https://discord.gg/fszyM7K)!

# About the author

[Devendra Yadav](https://community.figment.io/u/dev.koold)

# References

This tutorial is based on the official [Avalanche Documentation](https://docs.avax.network/build/tutorials/smart-digital-assets/wallet-nft-studio).


Learn how to create, mint, and transfer NFTs on Avalanche.

Create, Mint and Transfer NFTs with the Avalanche Wallet

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/smart-digital-assets/integrate-figment-and-metamask). 

# Video

{% embed url="https://www.youtube.com/watch?v=Q46YMR85ikc&feature=youtu.be&ab_channel=Avalanche" caption="Connect DataHub to Matamask" %}

# Setup

First, [create an account](https://datahub.figment.io/sign_up?service=avalanche) on DataHub. You'll get an email with a verification link. When you click it, you'll be signed into your DataHub dashboard.

# DataHub Dashboard 

Once you're logged in to your [DataHub dashboard](https://datahub.figment.io/), find the `Available protocols` section and select Avalanche. This will bring you to the Avalanche dashboard. Our free tier for Avalanche has a limit of 200,000 requests per day. If you want to make more requests per day, you can upgrade to one of our [paid options](https://datahub.figment.io/services/avalanche/prices).

# Avalanche Dashboard 

On the Avalanche dashboard, you'll data about your plan and your usage of Avalanche APIs.

Next, you'll see your API key. It will look something like this: `f81e193b9412a683af7101e964766c07`. This piece of information is used to authenticate you when you make calls to the Avalanche API. You must provide it when you make a call to an Avalanche API hosted by Figment.

As the table on the dashboard says, you can make an API call to Avalanche's mainnet at `avalanche--mainnet--rpc.datahub.figment.io`. You can make an API call to the Fuji testnet at `avalanche--fuji--rpc.datahub.figment.io`.

# Try it Out

Paste the following command into your computer's terminal to confirm that you can access the Avalanche API hosted by Figment. This `curl` is asking for the blockchainID of the X-Chain on the Fuji tesnet. Replace `APIKEYGOESHERE` with the API key you see on the Avalanche dashboard.

```text
curl --location --request POST 'https://avalanche--fuji--rpc.datahub.figment.io/apikey/APIKEYGOESHERE/ext/info' \--header 'Content-Type: application/json' \--data-raw '{    "jsonrpc":"2.0",    "id"     :1,    "method" :"info.getBlockchainID",    "params": {        "alias":"X"    }}'
```

If you are successfully able to POST to DataHub's full nodes then you should get the following response.

```json
{ 
    "jsonrpc": "2.0",
    "result": {
        "blockchainID": "2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm" },    "id": 1
}
```

# Set up Metamask

Let's connect our Metamask wallet to the Avalanche API hosted by Figment. Open Metamask and select the network drop-down menu. Then, select `Custom RPC`:

![](https://miro.medium.com/max/408/0*0HGM4O_J5iF3943S)

Now, fill in the boxes with the following values, depending on whether you want to connect to mainnet or the Fuji testnet. Again, replace `APIKEYGOESHERE` with your API key from Figment.

# Mainnet Settings

* **Network Name**: Figment C-Chain Mainnet
* **New RPC URL**: `https://avalanche--mainnet--rpc.datahub.figment.io/apikey/APIKEYGOESHERE/ext/bc/C/rpc`
* **ChainID**: `0xa86a`
* **Symbol**: AVAX
* **Explorer**: `https://cchain.explorer.avax.network`

# Fuji Settings 

* **Network Name**: Figment C-Chain Fuji
* **New RPC URL**: `https://avalanche--fuji--rpc.datahub.figment.io/apikey/APIKEYGOESHERE/ext/bc/C/rpc`
* **ChainID**: `0xa869`
* **Symbol**: AVAX
* **Explorer**: `https://cchain.explorer.avax-test.network`

![](https://miro.medium.com/max/989/1*Y7O1bBeTWnuQBAqTnwmqUQ.png)

After setting up all of the parameters, you should see this page, which shows your $empty$ balance.

![](https://miro.medium.com/max/358/1*q0HIWcI3okakwYV2glos0A.png)

# Conclusion

You have successfully connected Metamask to Avalanche DataHub and can interact with the C-Chain seamlessly. 

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [join our community today](https://discord.gg/fszyM7K)!



Learn how to leverage Avalanche DataHub for Metamask transactions

Connect DataHub to Metamask

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/platform/create-a-subnet). 

# Introduction

A [**Subnet**](https://docs.avax.network/learn/platform-overview#subnets) is a set of validators. A Subnet validates a set of blockchains. Each blockchain is validated by exactly one Subnet, which is specified on blockchain creation. Subnets are a powerful primitive that allow blockchains to have custom validator sets, which means one can create permissioned blockchains.

When a Subnet is created, a threshold and a set of keys are specified. $Actually the addresses of the keys, not the keys themselves, are specified.$ In order to add a validator to that subnet, _threshold_ signatures from those keys are needed. We call these the Subnet’s **control keys** and we call a control key’s signature on a transaction that adds a validator to a Subnet a **control signature.** The upshot is that a Subnet has control over its membership.

In this tutorial, we’ll create a new Subnet with 2 control keys and a threshold of 2.

## Generate the Control Keys

First, let’s generate the 2 control keys. To do so we call `platform.createAddress` This generates a new private key and stores it for a user.

To generate the first key:

```javascript
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.createAddress",
    "params": {
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

This gives the first control key $again, it actually gives the _address_ of the first control key$. The key is held by the user we just specified.

```javascript
{
    "jsonrpc": "2.0",
    "result": {
        "address": "P-avax1spnextuw2kfzeucj0haf0e4e08jd4499gn0zwg"
    },
    "id": 1
}
```

Generate the second key:

```javascript
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.createAddress",
    "params": {
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

The response contains the second control key, which is held by the user we just specified:

```javascript
{
    "jsonrpc": "2.0",
    "result": {
        "address": "P-avax1zg5uhuwfrf5tv852zazmvm9cqratre588qm24z"
    },
    "id": 1
}
```

## Create the Subnet

To create a Subnet we call `platform.createSubnet`.

```javascript
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.createSubnet",
    "params": {
        "controlKeys":[
            "P-avax1spnextuw2kfzeucj0haf0e4e08jd4499gn0zwg",
            "P-avax1zg5uhuwfrf5tv852zazmvm9cqratre588qm24z"
        ],
        "threshold":2,
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

The response gives us the transaction’s ID, which is also the ID of the newly created Subnet.

```javascript
{
    "jsonrpc": "2.0",
    "result": {
        "txID": "3fbrm3z38NoDB4yMC3hg5pRvc72XqnAGiu7NgaEp1dwZ8AD9g",
        "changeAddr": "P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u"
    },
    "id": 1
}
```

## Verifying Success

We can call `platform.getSubnets` to get all Subnets that exist:

```javascript
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getSubnets",
    "params": {},
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

The response confirms that our Subnet was created:

```javascript
{
    "jsonrpc": "2.0",
    "result": {
        "subnets": [
            {
                "id": "3fbrm3z38NoDB4yMC3hg5pRvc72XqnAGiu7NgaEp1dwZ8AD9g",
                "controlKeys": [
                    "KNjXsaA1sZsaKCD1cd85YXauDuxshTes2",
                    "Aiz4eEt5xv9t4NCnAWaQJFNz5ABqLtJkR"
                ],
                "threshold": "2"
            }
        ]
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P
```

## Add Validators to the Subnet

[This tutorial](https://docs.avax.network/build/tutorials/platform/add-a-validator) will show you how to add validators to a Subnet.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to create a Subnet on Avalanche

Create a Subnet

Learn how to make an Auction smart contract on Avalanche

Create an Auction with Bidding on Avalanche using ReactJS

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/platform/deploy-a-smart-contract-on-avalanche-using-remix-and-metamask). 

# Introduction

![](../../../.gitbook/assets/image%20%2811%29.png)

Avalanche's Primary Network is a subnet that has three chains: P-Chain, X-Chain, and C-Chain. The C-Chain is an instance of the Ethereum Virtual Machine powered by Avalanche’s Snowman consensus protocol. The [C-Chain RPC](https://docs.figment.io/network-documentation/avalanche/rpc-and-rest-api) can do anything a typical Ethereum client can by using the Ethereum-standard RPC calls. The immediate benefits of using the C-Chain rather than Ethereum are all of the benefits of using Avalanche. These properties could considerably improve the performance of DApps and the user experience.

Today, we will deploy and test a smart contract on Avalanche using Remix and MetaMask.

## Step 1. Setting up MetaMask

Log in to MetaMask -&gt; Click the Network drop-down -&gt; Select Custom RPC

![](../../../.gitbook/assets/image%20%2812%29.png)

**FUJI Testnet Settings:**

* **Network Name**: Avalanche FUJI C-Chain
* **New RPC URL**: 

  `https://avalanche--fuji--rpc.datahub.figment.io/apikey/APIKEYGOESHERE/ext/bc/C/rpc`

* **ChainID**: `0xa869`
* **Symbol**: `C-AVAX`
* **Explorer**: [https://cchain.explorer.avax-test.network](https://cchain.explorer.avax-test.network/)

**Avalanche Mainnet Settings:**

* **Network Name**: Avalanche Mainnet C-Chain
* **New RPC URL**: 

  `https://avalanche--mainnet--rpc.datahub.figment.io/apikey/APIKEYGOESHERE/ext/bc/C/rpc`

* **ChainID**: `0xa86a`
* **Symbol**: `C-AVAX`
* **Explorer**: [https://cchain.explorer.avax.network/](https://cchain.explorer.avax.network/)

**Local Testnet $AVASH$ Settings:**

* **Network Name**: Avalanche Local
* **New RPC URL**:[ ](http://localhost:9650/ext/bc/C/rpc)[http://localhost:9650/ext/bc/C/rpc](http://localhost:9650/ext/bc/C/rpc)
* **ChainID**: `0xa868`
* **Symbol**: `C-AVAX`
* **Explorer**: N/A

## Step 2. Funding your C-Chain address

### **Funding your C-Chain address on FUJI** <a id="d718"></a>

 Navigate to [https://faucet.avax-test.network/](https://faucet.avax-test.network/) and paste your C-AVAX address. All you need to do is add a “C-” prefix and the faucet will switch from AVAX to C-AVAX.

### Funding your C-Chain address on Mainnet <a id="1997"></a>

Funding your C-chain address on mainnet is done through a cross-chain swap from X-chain to C-chain. 

### Funding your C-chain address on local testnet

Deploy your own faucet. [Tutorial](https://medium.com/avalabs/the-ava-platform-tools-pt-2-the-ava-faucet-48f28da57146)

## Step 3. Remix: Connect MetaMask and deploy a smart contract.

Open [Remix](https://remix.ethereum.org/) -&gt; Select Solidity

![](../../../.gitbook/assets/image%20%2810%29.png)

Load or create the smart contracts that we want to compile and deploy using Remix file explorer.

For this example, we will deploy an ERC20 contract from [OpenZeppelin](https://openzeppelin.com/contracts).

![](../../../.gitbook/assets/image%20%2814%29.png)

Navigate to Deploy Tab -&gt; Open the “ENVIRONMENT” drop-down and select Injected Web3 $make sure MetaMask is loaded$

![](../../../.gitbook/assets/image%20%287%29.png)

Once we injected the web3-&gt; Go back to the compiler, and compile the selected contract -&gt; Navigate to Deploy Tab

![](../../../.gitbook/assets/image%20%2815%29.png)

Now, the smart contract is compiled, MetaMask is injected, and we are ready to deploy our ERC20. Click “Deploy.”

![](../../../.gitbook/assets/image%20%284%29.png)

Confirm the transaction on the MetaMask pop up.

![](../../../.gitbook/assets/image%20%2816%29.png)

Our contract is successfully deployed!

![](../../../.gitbook/assets/image%20%289%29.png)

Now, we can expand it by selecting it from the “Deployed Contracts” tab and test it out.

![](../../../.gitbook/assets/image%20%285%29.png)

The contract ABI and Bytecode are available on the compiler tab.

![](../../../.gitbook/assets/image%20%2813%29.png)

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Learn how to deploy and test a smart contract on Avalanche using Remix and MetaMask

Deploy a Smart Contract on Avalanche using Remix and MetaMask

In this tutorial we will be creating an Avalanche account on the X-Chain using the Avalanche JavaScript API and DataHub.

Unlike other popular blockchains, Avalanche comes with a set of different chains, each with its own purpose:

- Exchange Chain or **X-Chain** which handles asset transfers.
- Platform Chain or **P-Chain** is for network validators and staking.
- Contract Chain or **C-Chain** handles smart contract execution.

## X-Chain

The X-Chain acts as a decentralized platform for creating and trading digital smart assets, a representation of a real-world resource (such as equity or bonds) with a set of rules that govern its behavior, like "can’t be traded until tomorrow" or "can only be sent to US citizens".

One asset traded on the X-Chain is AVAX. When you issue a transaction to a blockchain on Avalanche, you pay a fee denominated in AVAX.

## P-Chain

The P-Chain is the metadata blockchain on Avalanche and coordinates validators, keeps track of active [subnets](https://support.avax.network/en/articles/4064861-what-is-a-subnet), and enables the creation of new subnets. The P-Chain implements the Snowman [consensus protocol](https://docs.avax.network/learn/platform-overview/avalanche-consensus).

## C-Chain

The C-Chain allows for the creation of smart contracts using the C-Chain’s API, and is an instance of the [Ethereum Virtual Machine](https://ethereum.stackexchange.com/questions/268/ethereum-block-architecture/6413#6413) (EVM) powered by Avalanche.

---

# Challenge

{% hint style="tip" %}
In `pages/api/avalanche/account.ts`, implement the function to create our private key. A private key is used to sign transactions on any Avalanche chain (X/P/C), and for educational purposes we'll use a single private key during the Pathway. To manage the keys we first configure the Keychain, a component for managing private/public key pairs and addresses. You must replace any instances of `undefined` with working code to accomplish this.
{% endhint %}

```typescript
//...
  try {
    const {network} = req.body;
    const client = getAvalancheClient();
    const chain = client.XChain();
    const keyChain = chain.keyChain();
    const keypair = keyChain.undefined; // There is a useful method to use here
    const secret = undefined;
    const address = undefined;
    res.status(200).json({
      secret,
      address,
    });
  }
//...
```

**Need some help?** Check out these tips

- Using the code completion feature of your favorite code editor, find a method which retrieves a KeyPair object.
- On the keypair instance, call a method to retrieve the `PrivateKey` in string format.
- On the keypair instance, call a method to retrieve the `Address` in string format.
- [**`AvalancheJS` create keypair example**](https://github.com/ava-labs/avalanchejs/blob/master/examples/evm/createKeypair.ts)

{% hint style="info" %}
You can [**join us on Discord**](https://discord.gg/fszyM7K), if you have questions or want help completing the tutorial.
{% endhint %}

Still not sure how to do this? No problem! The solution is below so you don't get stuck.

---

# Solution

```typescript
// solution
//...
  try {
    const {network} = req.body;
    const client = getAvalancheClient(network);
    const chain = client.XChain();
    const keyChain = chain.keyChain();
    const keypair = keyChain.makeKey();
    const secret = keypair.getPrivateKeyString();
    const address = keypair.getAddressString();
    res.status(200).json({
      secret,
      address,
    });
  }
//...
```

**What happened in the code above?**

- Calling the `makeKey` method will give us a usable keypair.
- `getPrivateKeyString` retrieves the string-formatted private key.
- `getAddressString` retrieves the string-formatted public key.

{% hint style="tip" %}
Do not forget to fund the newly created wallet using the [Avalanche testnet faucet](https://faucet.avax-test.network/) in order to activate it!
{% endhint %}

---

# Make sure it works

Once the code is complete and the file is saved, Next.js will rebuild the API route. Now click on **Generate a Keypair** and you should see:

![](../../../.gitbook/assets/pathways/avalanche/avalanche-account.gif)

---

# Conclusion

Nice! Now that you have an identity, it's time to interact with the blockchain.
You want to know the amount of tokens your account holds? Good, this is exactly what the next challenge is - querying Avalanche for an account balance.


In this tutorial, we'll learn how to create an account on the Avalanche blockchain

Create a Keypair

Learn how to use Truffle with the Avalanche C-Chain

Make an e-Voting dApp on Avalanche Fuji testnet

Since Avalanche operates on 3 chains (X/P/C), it allows users to transfer tokens in each direction.

AVAX tokens exist on the X-Chain, where they can be traded; on the P-Chain, where they can be provided as a stake when validating the Primary Network; and on the C-Chain, where they can be used in smart contracts or to pay for gas fees. Avalanche supports movement of AVAX between these chains. We'll be concentrating our efforts on X->C swaps, since the C-Chain is used for smart contract deployments.

Inter-chain transfers are performed via a 2-step process:

- Create the X-Chain export transaction -> (this tutorial)
- Create the C-Chain import transaction

Here we will focus on the first part, the **X-Chain export transaction**.

---

# Challenge

{% hint style="tip" %}
In `pages/api/avalanche/export.ts`, implement the function and try to create an export transaction from X-Chain to C-Chain. You must replace any instances of `undefined` with working code to accomplish this.
{% endhint %}

**Take a few minutes to figure this out**

```typescript
//...
  try {
    const {secret, network} = req.body;
    const client = getAvalancheClient(network);

    // Total amount we're transferring = 0.05 AVAX
    const amount = "50000000";

    // Taking inspiration for xChain do the same for cChain
    const [ xChain   , cChain    ] = [ client.XChain()            , undefined ];
    const [ xKeychain, cKeychain ] = [ xChain.keyChain()          , undefined ];
    const [ xKeypair , cKeypair  ] = [ xKeychain.importKey(secret), undefined ];
    const [ xAddress , cAddress  ] = [ xKeypair.getAddressString(), undefined ];

    // Fetch UTXOs (unspent transaction outputs)
    const { utxos } = await xChain.getUTXOs(xAddress)

    // Get the real ID for the cChain
    const chainId = undefined;

    // Prepare the export transaction from X -> C chain
    const exportTx = await xChain.buildExportTx(undefined)

    // Sign and send the transaction
    const hash = await xChain.issueTx(exportTx.sign(xKeychain))

    res.status(200).json(hash)
  }
//...
```

**Need some help?** Check out these links

- [**Code examples**](https://github.com/ava-labs/avalanchejs/tree/master/examples/avm)
- [**Manage X-Chain Keys**](https://docs.avax.network/build/tools/avalanchejs/manage-x-chain-keys)

{% hint style="info" %}
You can [**join us on Discord**](https://discord.gg/fszyM7K), if you have questions or want help completing the tutorial.
{% endhint %}

Still not sure how to do this? No problem! The solution is below so you don't get stuck.

---

# Solution

```typescript
// solution
//...
  try {
    const {secret, network} = req.body;
    const client = getAvalancheClient(network);
    // Total amount we're transferring = 0.05 AVAX
    const amount = "50000000";

    // Initialize chain components
    const [ xChain   , cChain    ] = [ client.XChain()            , client.CChain()             ];
    const [ xKeychain, cKeychain ] = [ xChain.keyChain()          , cChain.keyChain()           ];
    const [ xKeypair , cKeypair  ] = [ xKeychain.importKey(secret), cKeychain.importKey(secret) ];
    const [ xAddress , cAddress  ] = [ xKeypair.getAddressString(), cKeypair.getAddressString() ];

    // Get the real ID for the destination chain
    const chainId = await client.Info().getBlockchainID("C");

    // Fetch UTXOs (i.e unspent transaction outputs)
    const { utxos } = await xChain.getUTXOs(xAddress);

    // Prepare the export transaction from X -> C chain
    const exportTx = await xChain.buildExportTx(
        utxos, // Unspent transaction outputs
        new BN(amount), // Transfer amount
        chainId, // Target chain ID (for C-Chain)
        [cAddress], // Addresses being used to send the funds from the UTXOs provided
        [xAddress], // Addresses being used to send the funds from the UTXOs provided
        [xAddress], // Addresses that can spend the change remaining from the spent UTXOs
    )

    // Sign and send the transaction
    const hash = await xChain.issueTx(exportTx.sign(xKeychain));

    res.status(200).json(hash);
  }
//...
```

**What happened in the code above?**

- First, we need to build our C-Chain keypair. This works exactly the same way for X-Chain.
- Next, we determine the chainId.
- Next, we build our transaction the same way as for a simple **AVAX** transfer:
  - `cAddress` replacing `sender`.
  - `chainId` replacing `assetId`.
- Finally, we sign and send the transaction and return the transaction hash.

---

# Make sure it works

Once the code is complete and the file is saved, Next.js will rebuild the API route. Click on **Export 0.05 AVAX** and you should see the balance displayed on the page:

![](../../../.gitbook/assets/pathways/avalanche/avalanche-export.gif)

---

# Conclusion

Our next topic is to process the import of the cross-chain transfer. Time to import the AVAX we just sent to C-Chain. Let's go!


In this tutorial, we'll learn how to export your AVAX to another chain. 

Export Token from X-Chain to C-Chain

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/platform/transfer-avax-between-x-chain-and-c-chain). 

# Introduction

AVAX tokens exist on the X-Chain, where they can be traded, on the P-Chain, where they can be provided as a stake when validating the Primary Network, and on the C-Chain, where they can be used in smart contracts or to pay for gas. In this tutorial, we’ll send AVAX tokens between the X-Chain and C-Chain.

# Requirements

You've created your [Avalanche DataHub](https://datahub.figment.io/sign_up?service=avalanche) account and are familiar with [Avalanche's architecture](https://docs.avax.network/learn/platform-overview).

In order to send AVAX, you need to have some AVAX! You can get real AVAX by buying it on an exchange, or you can get testnet AVAX from the [AVAX Test Faucet](https://faucet.avax-test.network), which is a free and easy way to get to play around with Avalanche.

# Transferring AVAX using the web wallet

The easiest way to transfer AVAX between chains is to use [the Avalanche Wallet](https://wallet.avax.network/) which is a non-custodial and secure way to access and move AVAX.

The Avalanche Wallet source code can be found [here](https://github.com/ava-labs/avalanche-wallet).

### Step 1 - Open the Avalanche Wallet

![](../../../.gitbook/assets/wallet-x2p-01-login-1-%20%281%29%20%281%29.png)

Select **Access Wallet** to enter your wallet. To connect the wallet to a network other than the main Avalanche network, select **Mainnet** and choose the network to connect to.

### Step 2 - Log In to Your Wallet

You can access your wallet using the private key, mnemonic key phrase, keystore file or Ledger Nano S. C-Chain transfers via Ledger are not supported yet.

![](../../../.gitbook/assets/wallet-x2p-02-access.png)

After a successful login you will see your balance, assets portfolio and various other information.

### Step 3 - Go to the Cross Chain Tab

![](../../../.gitbook/assets/wallet-x2p-03-earn-1-%20%281%29.png)

Functionality for transferring tokens between chains is on the **Cross Chain** tab.

### Step 4 - Enter Amount to Transfer

You will be presented with a choice for **Source Chain** and **Destination Chain**. Select X-Chain and C-Chain, respectively. You will see your X and C balances, and an input field for entering the amount to transfer from source to destination chain.

![](../../../.gitbook/assets/wallet-x2c-01-x-c.png)

Enter the amount you wish to transfer from the X-Chain to the C-Chain.

### Step 5 - Confirm the Transaction

![](../../../.gitbook/assets/wallet-x2c-02-trasnfer.png)

Press **Confirm**, and then **Transfer** to initiate the transfer.

### Step 6 - Done!

A cross-chain transfer is a two step process: first a transaction to export the funds from the X-Chain, and another to import it to the C-Chain. The wallet will do both and show its the progress while doing so.

![](../../../.gitbook/assets/wallet-x2c-03-done.png)

That's it! You've transferred AVAX from the X-Chain to C-Chain! Now you can use them to deploy smart contracts on C-Chain.

### Transfer from the C-Chain to X-chain

To return the AVAX back to the X-Chain, you need to do the transfer in the opposite direction.

Swap source and destination chain, by selecting them from the **Source** and **Destination** dropdown menu. The rest of the process is the same: enter the amount, confirm and transfer.

# Transferring from the X-Chain to C-Chain with API Calls

If you're building an application on the Avalanche network, you may want to do the transfer programmatically as part of some broader functionality. You can do that by calling the appropriate APIs on an AvalancheGo node. The rest of the tutorial assumes you have access to an AvalancheGo node, AVAX tokens on the X-Chain, and user credentials [created]() and stored in the node's keystore.

All the example API calls below assume the node is running locally $that is, listening on `127.0.0.1`$. The node can be connected to the main network, a test network or a local network. In each case, the API calls and responses should be the same, except for the address formats. The node need not be local; you can make calls to a node hosted elsewhere.

As you may have noticed while transferring AVAX using the Avalanche Wallet, a cross-chain transfer is a two transaction operation:

* Export AVAX from the X-Chain
* Import AVAX to the C-Chain

Before we can do the transfer, we need to set up the address on the C-Chain, along with the controlling key.

### Set Up Address and Key on the C-Chain

The X-Chain uses [Bech32](http://support.avalabs.org/en/articles/4587392-what-is-bech32) addresses and the C-Chain uses hex Ethereum Virtual Machine $EVM$ addresses. There is no way to convert the address from one format to the other since they are both derived from a private key using a one-way cryptographic function.

In order to get around this, you can export a private key from the X-Chain and then import it to the C-Chain. This way, you can use the X-Chain address and change the X- prefix to a C- prefix in order to get the correct Bech32 address to use for the C-Chain.

First, export a private key from the X-Chain:

```cpp
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.exportKey",
    "params" :{
        "username" :"myUsername",
        "password":"myPassword",
        "address": "X-avax1jggdngzc9l87rgurmfu0z0n0v4mxlqta0h3k6e"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

Response:

```cpp
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "privateKey":"PrivateKey-2w4XiXxPfQK4TypYqnohRL8DRNTz9cGiGmwQ1zmgEqD9c9KWLq"
    }
}
```

Now, import the same private key to the C-Chain:

```cpp
curl -X POST --data '{  
    "jsonrpc":"2.0",    
    "id"     :1,    
    "method" :"avax.importKey", 
    "params" :{ 
        "username" :"myUsername",   
        "password":"myPassword",    
        "privateKey":"PrivateKey-2w4XiXxPfQK4TypYqnohRL8DRNTz9cGiGmwQ1zmgEqD9c9KWLq"    
    }   
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/C/avax
```

The response contains a hex-encoded EVM address:

```cpp
{
    "jsonrpc": "2.0",
    "result": {
        "address": "0x5Bf544EF123FE41B262295dBA41c5a9CFA8efDB4"
    },
    "id": 1
}
```

Now we have everything we need to transfer the tokens.

### Transfer from the X-Chain to C-Chain

Use the address corresponding to the private key you exported and switch to using the C- prefix in the [`avm.exportAVAX`]() call:

```cpp
curl -X POST --data '{  
    "jsonrpc":"2.0",    
    "id"     :1,    
    "method" :"avm.exportAVAX", 
    "params" :{ 
        "to":"C-avax1jggdngzc9l87rgurmfu0z0n0v4mxlqta0h3k6e",   
        "destinationChain": "C",    
        "amount": 5000000,  
        "username":"myUsername",    
        "password":"myPassword" 
    }   
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

Since your keystore user owns the corresponding private key on the C-Chain, you can now import the AVAX to the address of your choice. It’s not necessary to import it to the same address that it was exported to, so can import the AVAX to an address that you own in MetaMask or another third-party service.

```cpp
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,    
    "method" :"avax.importAVAX",    
    "params" :{ 
        "to":"0x4b879aff6b3d24352Ac1985c1F45BA4c3493A398",  
        "sourceChain":"X",  
        "username":"myUsername",    
        "password":"myPassword" 
    }   
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/C/avax
```

where `to` is a hex-encoded EVM address of your choice.

The response looks like this:

```cpp
{   
    "jsonrpc": "2.0",   
    "result": { 
        "txID": "LWTRsiKnEUJC58y8ezAk6hhzmSMUCtemLvm3LZFw8fxDQpns3" 
    },  
    "id": 1 
}
```

Note: there is no transaction fee for import transactions to the C Chain.

Once your AVAX has been transferred to the C-Chain, you can use it to deploy and interact with smart contracts.

## Transfer from the C-Chain to X-Chain

Now, you can move AVAX back from the C-Chain to the X-Chain. First we need to export:

```cpp
curl -X POST --data '{  
    "jsonrpc":"2.0",    
    "id"     :1,    
    "method" :"avax.exportAVAX",
    "params" :{ 
        "to":"X-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q",   
        "amount": 5000000,  
        "username":"myUsername",    
        "password":"myPassword" 
    }   
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/C/avax
```

where `to` is the bech32 encoded address of an X-Chain address you hold. Make sure that the amount you export exceeds the transaction fee because both the export and import transactions will charge a transaction fee.

The response should look like this:

```cpp
{   
    "jsonrpc": "2.0",   
    "result": { 
        "txID": "2ZDt3BNwzA8vm4CMP42pWD242VZy7TSWYUXEuBifkDh4BxbCvj"    
    },  
    "id": 1 
}
```

To finish the transfer, call [`avm.importAVAX`]().

```cpp
curl -X POST --data '{  
    "jsonrpc":"2.0",    
    "id"     :1,    
    "method": "avm.importAVAX", 
    "params": { 
        "username":"myUsername",    
        "password":"myPassword",    
        "sourceChain": "C", 
        "to":"X-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q"    
    }   
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

where `to` is the bech32 encoded address the X-Chain address which you sent the funds to in the previous step.

The response should look like this:

```cpp
{   
    "jsonrpc": "2.0",   
    "result": { 
        "txID": "2kxwWpHvZPhMsJcSTmM7a3Da7sExB8pPyF7t4cr2NSwnYqNHni"    
    },  
    "id": 1 
}
```

# Wrapping Up

That’s it! Now, you can swap AVAX back and forth between the X-Chain and C-Chain, both by using the Avalanche Wallet, and by calling the appropriate API calls on an Avalanche node.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [**join our community today**](https://discord.gg/fszyM7K)!



Transfer AVAX Between the X-Chain and C-Chain

Learn how to create a new virtual machine on Avalanche

Create a New Virtual Machine

We already know that Avalanche is not your typical blockchain, with P/X/C chains supporting various operations. Each of these chains also has its own set of transaction types, however, we are looking to create a very simple one - a _token transfer_, and specifically on the X-Chain.

In simple terms: We will be sending some AVAX tokens from address A to address B to simulate a payment for goods/services.

---

# Challenge

{% hint style="tip" %}
In `pages/api/avalanche/transfer.ts`, implement the function and try to make your first transfer on the Avalanche network. You must replace any instances of `undefined` with working code to accomplish this.
{% endhint %}

**Take a few minutes to figure this out**

```typescript
  try {
    const {secret, navax, recipient, address, network} = req.body;
    const client = getAvalancheClient(network);
    const chain = client.XChain();
    const keychain = chain.keyChain();
    // Using keychain, load the private key to sign transactions
    undefined;

    // Fetch UTXOs (unspent transaction outputs)
    const { utxos } = undefined;

    // Determine the real asset ID from its symbol/alias
    const binTools = BinTools.getInstance();
    const assetInfo = await chain.getAssetDescription("AVAX");
    const assetID = binTools.cb58Encode(assetInfo.assetID);

    // Create a new transaction
    const transaction = await chain.buildBaseTx(undefined);

    // Sign the transaction and send it to the network
    undefined;
    undefined;

    res.status(200).json(hash);
  }
//...
```

**Need some help?** Check out these links

- [**Transfer example**](https://github.com/ava-labs/avalanchejs/tree/master/examples/avm)
- [**Manage X-Chain Keys**](https://docs.avax.network/build/tools/avalanchejs/manage-x-chain-keys)
- [**What The Heck is UTXO**](https://medium.com/bitbees/what-the-heck-is-utxo-ca68f2651819)

{% hint style="info" %}
You can [**join us on Discord**](https://discord.gg/fszyM7K), if you have questions or want help completing the tutorial.
{% endhint %}

Still not sure how to do this? No problem! The solution is below so you don't get stuck.

---

# Solution

```typescript
// solution
//...
  try {
    const {secret, navax, recipient, address, network} = req.body;
    const client = getAvalancheClient(network);
    const chain = client.XChain();
    const keychain = chain.keyChain();
    keychain.importKey(secret);

    // Fetch UTXO (i.e unspent transaction outputs)
    const { utxos } = await chain.getUTXOs(address);

    // Determine the real asset ID from its symbol/alias
    // We can also get the primary asset ID with chain.getAVAXAssetID() call
    const binTools = BinTools.getInstance();
    const assetInfo = await chain.getAssetDescription("AVAX");
    const assetID = binTools.cb58Encode(assetInfo.assetID);

    // Create a new transaction
    const transaction = await chain.buildBaseTx(
      utxos, // Unspent transaction outputs
      new BN(navax), // Transaction amount, formatted as a BigNumber
      assetID, // AVAX asset
      [recipient], // Addresses we are sending the funds to (receiver)
      [address], // Addresses being used to send the funds from the UTXOs provided (sender)
      [address], // Addresses that can spend the change remaining from the spent UTXOs (payer)
    );

    // Sign the transaction and send it to the network
    const signedTx = transaction.sign(keychain);
    const hash = await chain.issueTx(signedTx);

    res.status(200).json(hash);
  }
//...
```

**What happened in the code above?**

- First, calling `importKey()` we pass the private key (`secret`), this allows the keypair to sign transactions.
- Next, we fetch the latest unspent transaction outputs with `getUTXOs`.
- Next, we determine the **assetID** using `BinTools.cb58Encode` method.
- Next, we build a base transaction using `buildBaseTx` passing:
  - The unspent outputs,
  - The transaction amount formatted as BigNumber,
  - The assetID,
  - The recipient address,
  - The sender address,
  - The payer address. Note that the sender and payer in this example are the same, but this is not required.
- Finally, we sign and send the transaction and return the transaction hash.

{% hint style="success" %}
A UTXO is an unspent transaction output. In an accepted transaction in a valid blockchain payment system, only unspent outputs can be used as inputs to a transaction. When a transaction takes place, inputs are deleted and outputs are created as new UTXOs that may then be consumed in future transactions.
{% endhint %}

{% hint style="tip" %}
Remember, the **AVAX** asset is using a 9-digit denomination and **AVAX** is the primary asset on the X-Chain.
{% endhint %}

---

# Make sure it works

Once the code is complete and the file is saved, Next.js will rebuild the API route.

- Fill in the amount of **nAVAX** you want to send.
- Click on **Submit Transfer**.

![](../../../.gitbook/assets/pathways/avalanche/avalanche-transfer.gif)

---

# Conclusion

We've learned how to prepare, sign and broadcast a simple transaction on Avalanche. With only a few lines of code, you can transfer funds on the network. AvalancheJS provides a range of examples on how to construct a transaction with more complex properties, for different use cases. In the next tutorial, we will examine the topic of cross-chain transfers.


In this tutorial, we'll learn how to transfer Token from one account to another

Transfer some AVAX

Learn how to deploy a distributed chat application on Avalanche using Solidity and the React framework

Create a chat dApp on Avalanche using Solidity and ReactJS

Learn how to create an Avalanche based dApp with a ReactJS frontend

Create a Voting dApp on Avalanche using ReactJS

# Introduction

Whether you are looking to create your own token, provide liquidity for existing tokens or trade on Pangolin that is deployed on Avalanche's c-chain, you will need to create a token pair on Pangolin.

However, before that, we must familiarize ourselves with the functionality of token pairs, so that we can simulate a universe of token pairs and wallets, or even test our assumptions about contracts and tokenomics on a [DEX](https://cryptocurrencyfacts.com/what-is-a-dex/). We will want to deploy a local testnet so that we can check our code for bugs and unintended interactions!

In this tutorial, we will illustrate how to create your own Pangolin exchange locally and also create a trading pair from any arbitrary ERC20 tokens.

## About Pangolin

Pangolin is a fork of Uniswap V2 and the first decentralized exchange $DEX$ on Avalanche c-chain where users can swap their [ERC20](https://eips.ethereum.org/EIPS/eip-20) tokens.

# Prerequisites

If you have completed the Avalanche tutorial on [Using Truffle with the Avalanche C-Chain](https://docs.avax.network/build/tutorials/smart-contracts/using-truffle-with-the-avalanche-c-chain), you will have completed most of the prerequisites.

You have to be mindful that `avalanchego` is being constantly improved and things may change from the time this tutorial is published $i.e. the address of the x/p/c chains used in the libraries above my differ from the current version of Avalanche JS, private keys may change, etc. This means that you may need to modify the code when getting your local test net up and running$.

In addition, you will need to 

* Install pangolin DEX exchange contracts:

```
npm install --dev @pangolindex/exchange-contracts
```

* Install OpenZepplin contracts

```
npm install --dev @openzeppelin/contracts
```

## Copy ERC20 Open Zeppelin Contracts to build directory

We now need to make sure we have access to ERC20 token contracts that we will use help create our token pair when we deploy it to pangolin.

These contracts will be found in the `node_modules` directory

```
cp node_modules/\@openzeppelin/contracts/build/contracts/ERC20.json build/contracts/
```

Similarly, we need to copy the IPangolinFactory and IPangolinPair interface contracts to our build directory.

```
cp node_modules/\@pangolindex/exchange-contracts/artifacts/contracts/pangolin-core/interfaces/IPangolinPair.sol/IPangolinPair.json build/contracts/

cp node_modules/\@pangolindex/exchange-contracts/artifacts/contracts/pangolin-core/interfaces/IPangolinFactory.sol/IPangolinFactory.json build/contracts/
```

## Create a new Migration file

We now need to create a new migration file called `3_deploy.js` with the content, following this; we will step through what is going on below:

```javascript
	const MockERC20 = artifacts.require('ERC20');
	const PangolinFactoryBytecode = require('@pangolindex/exchange-contracts/artifacts/contracts/pangolin-core/PangolinFactory.sol/PangolinFactory.json').bytecode
	const PangolinRouter02Bytecode = require('@pangolindex/exchange-contracts/artifacts/contracts/pangolin-periphery/PangolinRouter.sol/PangolinRouter.json').bytecode;
	const WAVAXBytecode = require('@pangolindex/exchange-contracts/artifacts/contracts/WAVAX.sol/WAVAX.json').bytecode;
	const IPangolinFactory = artifacts.require('IPangolinFactory');
	const IPangolinPair = artifacts.require('IPangolinPair');

	module.exports = function(deployer, network, accounts) {
	  deployer.then(async() => {
	    const OneERC20 = await deployer.deploy(MockERC20);
	  	const AnotherERC20 = await deployer.deploy(MockERC20);

	  	console.log('Deploy Pangolin Factory');
		// We need an address arg to the contract
		let pangolinArg = '';
		for (let i = 0; i < 32; i++) {
			pangolinArg += '00';
		}

		const pangolinFactoryAddress = (await web3.eth.sendTransaction({from: accounts[0], gas: 8000000, data: PangolinFactoryBytecode + pangolinArg})).contractAddress;

		console.log('Deploy wAVAX');
		const wAVAXAddress = (await web3.eth.sendTransaction({from: accounts[0], gas: 8000000, data: WAVAXBytecode})).contractAddress;

		console.log('Deploy Pangolin Router');
		const PangolinRouterAddress = (await web3.eth.sendTransaction({
		  from: accounts[0],
		  gas: 8000000,
		  data: PangolinRouter02Bytecode + web3.eth.abi.encodeParameters(['address', 'address'],[pangolinFactoryAddress, wAVAXAddress]).slice(2)
		})).contractAddress;

		console.log('PangolinRouter is at: ' + PangolinRouterAddress);

		const PangoFactoryInstance = await IPangolinFactory.at(pangolinFactoryAddress);
		const PangoPairTx = await PangoFactoryInstance.createPair(OneERC20.address, AnotherERC20.address);
		const PangoPairAddress = PangoPairTx['logs'][0]['args']['pair'];
		const PangoPair = await IPangolinPair.at(PangoPairAddress);

		console.log('OneERC20-AnotherERC20 Token pair is at: ' + PangoPairAddress);

	  })
	};
```

# Import Required Contracts/Bytecode

The first thing we need to do is to import the ERC20 contracts as well as the bytecode for the Pangolin Factory, Router, Pair Interface and Factory Interface and the Wrapped AVAX $wAVAX$.

```javascript
	const MockERC20 = artifacts.require('ERC20');
	const PangolinFactoryBytecode = require('@pangolindex/exchange-contracts/artifacts/contracts/pangolin-core/PangolinFactory.sol/PangolinFactory.json').bytecode
	const PangolinRouter02Bytecode = require('@pangolindex/exchange-contracts/artifacts/contracts/pangolin-periphery/PangolinRouter.sol/PangolinRouter.json').bytecode;
	const WAVAXBytecode = require('@pangolindex/exchange-contracts/artifacts/contracts/WAVAX.sol/WAVAX.json').bytecode;
	const IPangolinFactory = artifacts.require('IPangolinFactory');
	const IPangolinPair = artifacts.require('IPangolinPair');
```

## Deploy Mock Tokens

Next, we need to deploy the mock ERC20 tokens.

These could be any other kind of ERC20 tokens, but for simplicity, we simply deploy the same contract to a different address.

```javascript
	const OneERC20 = await deployer.deploy(MockERC20);
	const AnotherERC20 = await deployer.deploy(MockERC20);
```

## Construct Zero Address Argument And Deploy Factory

In order to construct any token pair on Pangolin, you will need to interact with the Factory contract and that means we need to deploy it to our local testnet first.

By appending a zero address to the bytecode of the contract, we make a transaction with the data to store it on-chain.

```javascript
	let pangolinArg = '';
	for (let i = 0; i < 32; i++) {
		pangolinArg += '00';
	}
	const pangolinFactoryAddress = (await web3.eth.sendTransaction({from: accounts[0], gas: 8000000, data: PangolinFactoryBytecode + pangolinArg})).contractAddress;
```

## WAVAX

As with ETH, AVAX is not ERC20 compliant and since it's the native token on avalanche, it must be wrapped.

It is also needed to deploy the router $a holdover from the Uniswap V1 architecture that required ERC20 tokens to be swapped for ETH before being swapped for another ERC20 token$.

We need to create a transaction where we send the WAVAX bytecode and get back the address.

```javascript
	const wAVAXAddress = (await web3.eth.sendTransaction({from: accounts[0], gas: 8000000, data: WAVAXBytecode})).contractAddress;
```

# Router

After we have deployed the bytecode for both the factory and WAVAX, we will take the address and append them as arguments to the router bytecode.

In doing this, we will then be able to interact with all the router functions of the exchange in downstream applications.

Not too different from what we have done for the router and WAVAX, we will create a transaction and get the address of the deployed bytecode.

```javascript
	const PangolinRouterAddress = (await web3.eth.sendTransaction({
	  from: accounts[0],
	  gas: 8000000,
	  data: PangolinRouter02Bytecode + web3.eth.abi.encodeParameters(['address', 'address'],[pangolinFactoryAddress, wAVAXAddress]).slice(2)
	})).contractAddress;
```

## Pangolin Factory interface $IPangolinFactory$ and PangolinPair interface $IPangolinPair$

The interface for the factory and pair token contracts isn’t necessarily needed here because we are deploying both contracts themselves and we could use the contract ABI directly.

However, if we were going to access these through another contract, they would allow us to be able to still call the methods defined on PangolinFactory and PangolinPair even if those underlying contracts changed in the future if while only needing to change the address.

For example, if you wanted to modify PangolinPair and PangolinRouter without changing the contracts you may have already deployed $assuming they have a way to pull in the new address$, then you will easily be able to do this if you deployed your contracts with the interfaces.

## Create Pair with router and pair interfaces

For the final step, we need to access the instance of the factory address through the interface.

Once that is done, we will call `createPair` on the instance with our ERC20 token address as arguments.

This will generate a transaction that we will need to parse the logs and get the pair address.

Then if you wanted to later call functions on the pair address, you need to access the address through the pair interface.

```javascript
	const PangoFactoryInstance = await IPangolinFactory.at(pangolinFactoryAddress);
	const PangoPairTx = await PangoFactoryInstance.createPair(OneERC20.address, AnotherERC20.address);
	const PangoPairAddress = PangoPairTx['logs'][0]['args']['pair'];
	const PangoPair = await IPangolinPair.at(PangoPairAddress);
```

# Conclusion

In this tutorial we have covered:

* Gathering the needed contract files
* Creating a new migration file
* Importing the contract files and bytecode
* Deploying mock ERC20 Tokens
* Deploying Pangolin Factory
* Deploying WAVAX
* Deploying Pangolin Router
* Creating a token pair with our mock ERC20 Tokens

You have now deployed Pangolin to your local testnet with your two ERC20 tokens, created a pair token from the ERC20 tokens and now are ready to interact with pangolin through the router as you would on Uniswap v2.

# About the Author

This Tutorial was created by [Cinque McFarlane-Blake](https://github.com/cinquemb). Cinque is a reluctant software engineer and he worked on projects at labs related to brain-computer interfaces, back office stuff for trading in futures markets, and academic publishing tools in developing markets. Overall, He is just trying to help build a more decentralized hyper-connected world while pushing on the boundaries of our existence.

We will learn how to deploy Pangolin, a DEX which lives on C-Chain, to your local Avalanche testnet.

Deploy Pangolin To Your Local Testnet And Create Token Pair

# Set your Datahub API key

Create an `.env.local` file at the root of the directory. Copy and paste the contents of the existing `.env.example` into the new file and save it to disk (you could also rename `.env.example` to `.env.local`).

The value for `DATAHUB_AVALANCHE_API_KEY` can be found on the [**DataHub Services Dashboard**](https://datahub.figment.io/services/secret). Click on the **Avalanche** icon in the list of available protocols and then copy your key as shown below. You can now paste your personal API key into `.env.local`. This will authenticate you and enable you to make JSON-RPC requests to Secret via DataHub.

![](../../../.gitbook/assets/pathways/avalanche/avalanche-setup.gif)

{% hint style="info" %}
[**Join us on Discord**](https://discord.gg/fszyM7K), if you encounter any issues with the tutorial or have any questions!**
{% endhint %}

---------------------------

# Next

You can now move ahead to the next step by clicking on the "Next" button below on the right. There are also links to the instructions for each step on the UI.


Let's setup the project to connect & interact with Avalanche

Setup the project

Now that you have created an account on the Avalanche **Fuji** testnet and funded it using the faucet - We're going to check the balance of the account to make sure everything went alright. The native token of the **Avalanche** blockchain is **AVAX**, so we will want to start on the X-Chain.

---

# Challenge

{% hint style="tip" %}
In `pages/api/avalanche/balance.ts`, implement the default function. You must replace any instances of `undefined` with working code to accomplish this.
{% endhint %}

```typescript
//...
  try {
    const {network, address} = req.body;
    const client = getAvalancheClient(network);
    const chain = client.XChain();
    const balance = undefined;
    res.status(200).json(balance.balance);
  }
//...
```

**Need some help?** Check out these tips

- The `getBalance` method of the `AVMAPI` module looks like a good candidate!
- [**Code examples**](https://github.com/ava-labs/avalanchejs/tree/master/examples/avm)

{% hint style="info" %}
You can [**join us on Discord**](https://discord.gg/fszyM7K), if you have questions or want help completing the tutorial.
{% endhint %}

Still not sure how to do this? No problem! The solution is below so you don't get stuck.

---

# Solution

```typescript
// solution
//...
  try {
    const {network, address} = req.body;
    const client = getAvalancheClient(network);
    const chain = client.XChain();
    const balance = await chain.getBalance(address, "AVAX") as BalanceT;
    res.status(200).json(balance.balance);
  }
//...
```

**What happened in the code above?**

- The `getBalance` method will return the current balance of the specified asset (like AVAX) for the specified address.

{% hint style="tip" %}
The amount returned by is denominated in **nAVAX**, so to convert it to **AVAX** you'll need to divide it by 10\*\*9
{% endhint %}

---

# Make sure it works

Once the code is complete and the file is saved, Next.js will rebuild the API route. Click on **Check Balance** and you should see the balance displayed on the page:

![](../../../.gitbook/assets/pathways/avalanche/avalanche-balance.gif)

---

# Conclusion

Querying the balance information is fun, but being able to submit transactions and change the state of a blockchain is even better! In the next step, we will dive deeper and submit our first transactions on Avalanche.


In this tutorial, we'll learn how to check our account balance

Get the balance

[**The original tutorial can be found in the AVA Labs documentation here**](https://docs.avax.network/build/tutorials/smart-digital-assets/creating-a-nft-part-1). 

# Introduction

Avalanche is a global financial network for the issuance and trade of digital goods. On Avalanche, these digital goods are represented as tokens, which can be assets or utilities. Some tokens are **fungible**, which means that one token is interchangeable for any other one token. Real-world currency is fungible, for example; one $5 note is treated as being the same as any other $5 note.

Avalanche also supports non-fungible tokens $NFTs$. By definition, each NFT is unique and not perfectly interchangeable for any other NFT. For example, there could be an NFT that represents ownership of a real-world piece of art; each piece of art, like each NFT, is unique. NFTs represent digital scarcity and may prove to have even greater utility than traditional fungible tokens.

In this tutorial we’ll create and send NFTs using AvalancheGo’s API. In a future tutorial we’ll create a custom NFT family using [AvalancheJS](https://docs.avax.network/build/tools/avalanchejs) and explore NFTs in more detail.

# Requirements 

We assume that you’re already familiar with [**DataHub**](https://datahub.figment.io/sign_up?service=avalanche) and connecting to the Avalanche services. In this tutorial, we use [Avalanche’s Postman collection](https://github.com/ava-labs/avalanche-postman-collection) to help us make API calls.

# Create the NFT Family

Each NFT belongs to a **family**, which has a name and a symbol. Each family is composed of **groups**. The number of groups in a family is specified when the family is created. Our NFT will exist on the X-Chain, so to create our NFT family we’ll call `avm.createNFTAsset`, which is a method of the [X-Chain API](https://docs.figment.io/network-documentation/avalanche/rpc-and-rest-api)

The signature for this method is:

```javascript
avm.createNFTAsset({
    name: string,
    symbol: string,
    minterSets []{
        minters: []string,
        threshold: int
    },
    from: []string,
    changeAddr: string,
    username: string,
    password: string
}) ->
{
    assetID: string,
    changeAddr: string,
}
```

**Method**

* `avm.createNFTAsset`

**Parameters**

* `name` is a human-readable name for our NFT family. Not necessarily unique. Between 0 and 128 characters.
* `symbol` is a shorthand symbol for this NFT family. Between 0 and 4 characters. Not necessarily unique. May be omitted.
* `minterSets` is a list where each element specifies that `threshold` of the addresses in `minters` may together mint more of the asset by signing a minting operation.
* Performing a transaction on the X-Chain requires a transaction fee paid in AVAX. `username` and `password` denote the user paying the fee.
* `from` are the addresses that you want to use for this operation. If omitted, uses any of your addresses as needed.
* `changeAddr` is the address any change will be sent to. If omitted, change is sent to any of your addresses.

**Response**

* `assetID` is the ID of the new asset that we’ll have created.
* `changeAddr` in the result is the address where any change was sent.

Later in this example we’ll mint an NFT, so be sure to replace at least 1 address in the minter set with an address which your user controls.

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.createNFTAsset",
    "params" :{
        "name":"Family",
        "symbol":"FAM",
        "minterSets":[
            {
                "minters": [
                    "X-avax1ghstjukrtw8935lryqtnh643xe9a94u3tc75c7"
                ],
                "threshold": 1
            }
        ],
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response should look like this:

```json
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "assetID":"2X1YV4jpGpqezvj2khQdj1yEiXU1dCwsJ7DmNhQRyZZ7j9oYBp",
        "changeAddr":"X-avax1ghstjukrtw8935lryqtnh643xe9a94u3tc75c7"
    }
}
```

A couple things to note: first, in addition to creating an NFT family, AvalancheGo’s `avm.createNFTAsset` also creates a group for each of the `minterSets` which are passed in. For example, if `minterSets` has 3 elements, the NFT family has 3 groups. Second, take note of the `assetID` which is returned in the response. This is the `assetID` of the newly created NFT family and you’ll need it later to issue NFTs.

You may be wondering why we specify _sets_ of addresses that can mint more units of the asset rather than a single address. The first reason is security: if only one address can mint more of the asset, and the private key for that address is lost, no more units can ever be minted. Similarly, if only one address can mint more of the asset, nothing stops the holder of that address from unilaterally minting as much as they want. The second reason is flexibility. It’s nice to be able to encode logic like, “Alice can unilaterally mint more units of this asset, or 2 of Dinesh, Ellin and Jamie can together mint more.” Let’s now create an NFT underneath the family we just created.

NFT outputs don’t show up in calls to `avm.getBalance` or `avm.getAllBalances`. To see your NFTs you have to call `avm.getUTXOs` and then parse the utxo to check for the type ID. NFT Mint Outputs have a type id of `00 00 00 0a` in hexidecimal $`10` in decimal$ and NFT Transfer Outputs have a type id of `00 00 00 0b` in hexdecimal $`11` in decimal.$

**Method**

* `avm.getUTXOs`

**Parameters:**

* `addresses` are the addresses to fetch UTXOs for.

**Response:**

* `numFetched` is the total number of UTXOs in the response.
* `utxos` is an array of CB58 encoded strings.
* `endIndex` This method supports pagination. `endIndex` denotes the last UTXO returned.

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.getUTXOs",
    "params" :{
        "addresses":["X-avax1ghstjukrtw8935lryqtnh643xe9a94u3tc75c7"]
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response contains a list of UTXOs:

```json
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "numFetched": "2",
        "utxos": [
            "116VhGCxiSL4GrMPKHkk9Z92WCn2i4qk8qdN3gQkFz6FMEbHo82Lgg8nkMCPJcZgpVXZLQU6MfYuqRWfzHrojmcjKWbfwqzZoZZmvSjdD3KJFsW3PDs5oL3XpCHq4vkfFy3q1wxVY8qRc6VrTZaExfHKSQXX1KnC",
            "11cxRVipJgtuHy1ZJ6qM7moAf3GveBD9PjHeZMkhk7kjizdGUu5RxZqhViaWh8dJa9jT9sS62xy73FubMAxAy8b542v3k8frTnVitUagW9YhTMLmZ6nE48Z9qXB2V9HHzCuFH1xMvUEj33eNWv5wsP3JvmywkwkQW9WLM"
        ],
        "endIndex": {
            "address": "X-avax1ghstjukrtw8935lryqtnh643xe9a94u3tc75c7",
            "utxo": "2iyUVo8XautXpZwVfp5vhSh4ASWbo67zmHbtx7SUJg2Qa8BHtr"
        }
    }
}
```

`avm.getUTXOs` returns 2 UTXOs. Let’s take the first one and decode it to confirm that it’s an[ NFT Mint Output](https://docs.avax.network/build/references/avm-transaction-serialization#nft-mint-output). First we convert the Base58Check encoded string which is returned from `avm.getUTXOs` in to hex. The following CB58 string:

```
116VhGCxiSL4GrMPKHkk9Z92WCn2i4qk8qdN3gQkFz6FMEbHo82Lgg8nkMCPJcZgpVXZLQU6MfYuqRWfzHrojmcjKWbfwqzZoZZmvSjdD3KJFsW3PDs5oL3XpCHq4vkfFy3q1wxVY8qRc6VrTZaExfHKSQXX1KnC
```

is expressed in hexadecimal as:

```
00 00 04 78 f2 39 8d d2 16 3c 34 13 2c e7 af a3 1f 0a c5 03 01 7f 86 3b f4 db 87 ea 55 53 c5 2d 7b 57 00 00 00 01 04 78 f2 39 8d d2 16 3c 34 13 2c e7 af a3 1f 0a c5 03 01 7f 86 3b f4 db 87 ea 55 53 c5 2d 7b 57 00 00 00 0a 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 01 3c b7 d3 84 2e 8c ee 6a 0e bd 09 f1 fe 88 4f 68 61 e1 b2 9c
```

Now we can decompose the hex in to the UTXO’s indivdual components by referring to the[ transaction serialization format](https://docs.avax.network/build/references/avm-transaction-serialization):

```
NFT Mint Output

CodecID: 00 00
TXID: 04 78 f2 39 8d d2 16 3c 34 13 2c e7 af a3 1f 0a c5 03 01 7f 86 3b f4 db 87 ea 55 53 c5 2d 7b 57
Output Index: 00 00 00 01
AssetID: 04 78 f2 39 8d d2 16 3c 34 13 2c e7 af a3 1f 0a c5 03 01 7f 86 3b f4 db 87 ea 55 53 c5 2d 7b 57
TypeID: 00 00 00 0a
GroupID: 00 00 00 00
Locktime: 00 00 00 00 00 00 00 00
Threshold: 00 00 00 01
Address Count: 00 00 00 01
Addresses[0]: 3c b7 d3 84 2e 8c ee 6a 0e bd 09 f1 fe 88 4f 68 61 e1 b2 9c
```

Note that the `TypeID` is `00 00 00 0a` which is the correct type ID for an NFT Mint Output. Also note that the `GroupID` is `00 00 00 00`. This `GroupID` was created based on the number of `MinterSets` which I passed in to `avm.createNFTAsset`.

# Mint the Asset

Now that we have an NFT family and a group for the single `MinterSet` we’re able to creat NFTs belonging to this group. To do that we call avm.mintNFT:

**Method**

* `avm.mintNFT`

**Parameters**

* `assetID` is the ID of the NFT family.
* `payload` is an arbitrary CB58 encoded payload of up to 1024 bytes. In Part 2 $**COMING SOON**$ we’ll explore creating a protocol around the NFT payload. For this tutorial the payload is the string “AVA Labs”.
* `to` is the address that will receive the newly minted NFT. Replace `to` with an address your user controls so that later you’ll be able to send some of the newly minted NFT.
* `username` must be a user that holds keys giving it permission to mint more of this NFT. That is, it controls at least _threshold_ keys for one of the minter sets we specified above.
* `password` is the valid password for `username`

**Response**

* `txID` is the transaction ID.
* `changeAddr` in the result is the address where any change was sent.

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.mintNFT",
    "params" :{
        "assetID":"2X1YV4jpGpqezvj2khQdj1yEiXU1dCwsJ7DmNhQRyZZ7j9oYBp",
        "payload":"2EWh72jYQvEJF9NLk",
        "to":"X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv",
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response contains the transaction’s ID:

```json
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "txID":"x4fKx95KirTvqWCeiPZfnjB4xFdrTduymRKMouXTioXojdnUm",
        "changeAddr": "X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv"
    }
}
```

Similar to the previous step, we can now confirm that an NFT was minted by calling `avm.getUTXOs` and parsing the UTXO to confirm that we now have an [NFT Transfer Output](https://docs.avax.network/build/references/avm-transaction-serialization#nft-transfer-output).

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     : 1,
    "method" :"avm.getUTXOs",
    "params" :{
        "addresses":["X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv"]
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

This should give:

```json
{
    "jsonrpc": "2.0",
    "result": {
        "numFetched": "2",
        "utxos": [
            "11Do4RK6FchGXeoycKujR7atm3tvBz3qc64uoipCc5J74Sj1U4orM6vbBGSES8hnjgjZava9oPgmnbHxh2mBKjeXdvAqTRtYMHEacrveSzKgk7F8h8xi8JB9CddoiX8nbjZMYt1keGo5Rvpjh8dGymDWwRbV1FdnG5uDiiyU8uidc3P24",
            "11JL98R9yVoCaekrzP2PoCKJfCTin6vhTWU4h9TxqevEUnhiMo2j7F4DHxRpHq6BnFnHGAajhmiXgrdfUbbNd1izmdLVMwqe3UCTJWWLaJ6XUZ46R243T8NdhKXXJWC9GvcjFYMyiKRWvVnvFt7duzq8P8D53uhv1QfdQ9"
        ],
        "endIndex": {
            "address": "X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv",
            "utxo": "2qs3A1sBhVjFcXqRADJ7AorvoawVgMkNdgJi8eYNPABMKmdBYq"
        }
    },
    "id": 1
}
```

As in the previous step, we can now decode the CB58 encoded UTXO to hexidecimal and then decompose it to it’s individual components to confirm that we have the correct UTXO and type.

First we convert the Base58Check encoded string which is returned from `avm.getUTXOs` in to hex. The following CB58 string:

```
11Do4RK6FchGXeoycKujR7atm3tvBz3qc64uoipCc5J74Sj1U4orM6vbBGSES8hnjgjZava9oPgmnbHxh2mBKjeXdvAqTRtYMHEacrveSzKgk7F8h8xi8JB9CddoiX8nbjZMYt1keGo5Rvpjh8dGymDWwRbV1FdnG5uDiiyU8uidc3P24
```

is expressed in hexadecimal as:

```
00 00 7d 07 0d 1e fe a6 4e 45 09 05 c6 11 ee b1 cf 61 9f 21 22 eb 17 db aa ea 9a fe 2d ff 17 be 27 6b 00 00 00 01 04 78 f2 39 8d d2 16 3c 34 13 2c e7 af a3 1f 0a c5 03 01 7f 86 3b f4 db 87 ea 55 53 c5 2d 7b 57 00 00 00 0b 00 00 00 00 00 00 00 08 41 56 41 20 4c 61 62 73 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 01 3c b7 d3 84 2e 8c ee 6a 0e bd 09 f1 fe 88 4f 68 61 e1 b2 9c
```

Now we can decompose the hex in to the UTXO’s indivdual components:

```
NFT Mint Output

CodecID: 00 00
TXID: 7d 07 0d 1e fe a6 4e 45 09 05 c6 11 ee b1 cf 61 9f 21 22 eb 17 db aa ea 9a fe 2d ff 17 be 27 6b
Output Index: 00 00 00 01
AssetID: 04 78 f2 39 8d d2 16 3c 34 13 2c e7 af a3 1f 0a c5 03 01 7f 86 3b f4 db 87 ea 55 53 c5 2d 7b 57
TypeID: 00 00 00 0b
GroupID: 00 00 00 00
Payload Length: 00 00 00 08
Payload: 41 56 41 20 4c 61 62 73
Locktime: 00 00 00 00 00 00 00 00
Threshold: 00 00 00 01
Address Count: 00 00 00 01
Addresses[0]: 3c b7 d3 84 2e 8c ee 6a 0e bd 09 f1 fe 88 4f 68 61 e1 b2 9c
```

Note that the `TypeID` is `00 00 00 0b` which is the correct type id for an [NFT Transfer Output.](https://docs.avax.network/build/references/avm-transaction-serialization#nft-transfer-output) Also note that the Payload is included.

# Send the NFT

Now you can send the NFT to anyone. To do that, use AvalancheGo’s `avm.sendNFT` API method.

**Method**

* `avm.sendNFT`

**Parameters**

* `assetID` is the ID of the NFT we’re sending.
* `to` is the address that will receive the newly minted NFT.
* `groupID` is the NFT group from which to send the NFT.
* `username` is the user that controls the NFT.
* `password` is the valid password for `username`

**Response**

* `txID` is the transaction ID.
* `changeAddr` in the result is the address where any change was sent.

```
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.sendNFT",
    "params" :{
        "assetID" :"2X1YV4jpGpqezvj2khQdj1yEiXU1dCwsJ7DmNhQRyZZ7j9oYBp",
        "to"      :"X-avax1ghstjukrtw8935lryqtnh643xe9a94u3tc75c7",
        "groupID" : 0,
        "username":"USERNAME GOES HERE",
        "password":"PASSWORD GOES HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X
```

The response confirms that our NFT Transfer Operation was successful:

```json
{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "txID": "txtzxcrzPx1sn38HWKU9PB52EpbpXCegbdHNxPNAYd9ZvezJq",
        "changeAddr": "X-avax1a202a8pu5w4vnerwzp84j68yknm6lf47drfsdv"0
    }
}
```

You can call `avm.getUTXOs` for the address which you sent the NFT to and decompose the returned UTXO, after converting from CB58 to hex, to confirm that there is a UTXO with type id `00 00 00 0b` in hex or `11` in decimal.

# Conclusion

Blockchain technology and tokenomics represent a radical new way of representing digital assets. Non-fungible tokens allow scarce assets to be tokenized. In this tutorial, we:

* Used `createNFTAsset` to create a non-fungible asset family and group.
* Used `mintNFT` to mint units of an NFT to the group.
* Used `getUTXOs` to fetch UTXOs for an address. We then converted the CB58 encoded UTXO to hex and decomposed it to it’s individual components.
* Used `sendNFT` to transfer NFTs between addresses.

In Part 2 of this series we’ll go more in depth by using AvalancheJS to create a protocol for our NFT payload and by issuing to multiple groups.

If you had any difficulties following this tutorial or simply want to discuss Avalanche tech with us you can [*oin our community today](https://discord.gg/fszyM7K)!

