# LOGOSNODOS

This made by LOGOSNODOS with taste LOVE for my beloved COMMUNITY

<figure><img src="/files/mtmWIDk7mZVHcx84h4DQ" alt=""><figcaption></figcaption></figure>


# Avail Network

Stake with LOGOSNODOS

<figure><img src="/files/yJl4PDzYxEB9eIWMqXNO" alt=""><figcaption></figcaption></figure>

Avail is a modular blockchain with a data availability layer designed to scale blockchain networks.

Website : [https://www.availproject.org](https://www.availproject.org/)

Twitter : <https://twitter.com/AvailProject>

Discord : <https://discord.gg/availproject>


# Installation

**Step 1: Update and install packages for compiling**

```
sudo apt update && sudo apt upgrade -y
sudo apt install curl git wget htop tmux build-essential jq make lz4 gcc unzip -y
```

**Step 2: Install Rust**

```php
curl https://sh.rustup.rs -sSf | sh
```

Select 1 and enter

**Step 3: Go to home**

```php
source $HOME/.cargo/env
```

**Step 4: Update rust**

```php
rustup update nightly
```

**Step 5: Add tools**

```php
rustup target add wasm32-unknown-unknown --toolchain nightly
```

**Step 6: Access Avail folder**

```php
mkdir avail
cd avail
```

**Step 7: Download Binary**

```
wget https://github.com/availproject/avail/releases/download/v2.2.5.1/x86_64-ubuntu-2204-avail-node.tar.gz
```

**Step 8: Extract**

```
tar -xf x86_64-ubuntu-2204-avail-node.tar.gz
```

**Step 9: run node**

```php
./avail-node --chain mainnet --name "Validator Moniker" --validator -d ./node-data
```

CTRL + C to escape (You need to run validator to your system to make system running 24/7)

**Step 10: Edit service file**

```php
sudo nano /etc/systemd/system/availd.service
```

*Change your Validator Moniker*

```php
[Unit]
Description=Avail Validator
After=network.target
StartLimitIntervalSec=0
[Service]
User=root
ExecStart= /root/avail/avail-node -d /root/avail/node-data --chain mainnet --validator --name "Validator Moniker"
Restart=always
RestartSec=120
[Install]
WantedBy=multi-user.target
```

**Step 11: Enable the service file**

```php
sudo systemctl daemon-reload
sudo systemctl enable availd.service
```

**Step 12: Start service file**

```php
sudo systemctl start availd.service
```

**Step 13: Check status of service**

```php
sudo systemctl status availd.service
```

**Step 14: Check logs**

```php
journalctl -f -u availd
```

Thank's to ADAM\_VNBnode for the guide it's very clear and we reshare for our community \
Source : <https://github.com/vnbnode/VNBnode-Guides/blob/main/Mainnet/Avail/avail_mainnet.md>


# Staking / Bonding

Note : Minimum Bonding is 50K AVL for mainnet (will be decrease in the future). There's 2 side I will separate on this guide VPS and DASHBOARD

* <mark style="color:red;background-color:green;">**ON YOUR VPS**</mark>

1. Generate session keys

```
curl -H "Content-Type: application/json" -d '{"id":1, "jsonrpc":"2.0", "method": "author_rotateKeys", "params":[]}' http://localhost:9944
```

2. Restart node

```
sudo systemctl restart availd.service
```

*Note : Save your session keys it will needed to connect your dashboard with your node*

* <mark style="color:red;background-color:green;">**ON YOUR DASHBOARD**</mark>

1. Navigate to the Avail network explorer at [https://explorer.avail.so/(opens in a new tab)](https://explorer.avail.so/) and choose the correct network.
2. Create a `stash` account.
3. Navigate to the **Staking** tab in the Explorer.
4. Click on `Stash` to initiate the bonding process.

<figure><img src="/files/ntj1TvLzesWj5GwFYyZa" alt=""><figcaption><p><em>Tips : Don't BOND all your tokens because you need some gas fee (you can increase your bonding anytime soon)</em></p></figcaption></figure>

5. Fill in the bonding preferences. Then click `Bond` and `Sign and Submit`.&#x20;

<figure><img src="https://docs.availproject.org/img/bonding-preference.png" alt=""><figcaption><p><em>Minimum bonding for joining mainnet is 50K AVL</em></p></figcaption></figure>

6. Click on `Session Key` and enter the hex-encoded result. (*Input your session keys that I mention to saved before*)
7. Click `Set Session Key` -> `Sign and Submit`and enter your password when prompted.

<figure><img src="https://docs.availproject.org/img/avail/set-session-keys.png" alt=""><figcaption><p><em>After submitting the extrinsic, you'll observe that <strong>Set Session Key</strong> changes to <strong>Validate</strong>. Make sure your node is fully synchronized before proceeding further.</em></p></figcaption></figure>

8. Click `Validate` on the **Staking** tab.

<figure><img src="https://docs.availproject.org/img/avail/start-validating.png" alt=""><figcaption></figcaption></figure>

9. Set your validator commission percentage.
10. Enter your password and click `Validate`.

<figure><img src="https://docs.availproject.org/img/avail/set-validate-commission.png" alt=""><figcaption></figcaption></figure>

<mark style="color:red;background-color:green;">CONGRATULATIONS !!!</mark>

Your validator is now prepared to begin the validation process. If you wish to discontinue, you can click the stop icon. Please note that the Avail interface doesn't automatically verify if your node is synchronized; you'll need to confirm this manually. If your node has sufficient stake, the Avail blockchain will likely select it in the next epoch or two.

<figure><img src="https://docs.availproject.org/img/avail/validator-ready.png" alt=""><figcaption></figcaption></figure>


# AR.IO

<figure><img src="/files/U5Y2GdEmKBAKttSVMUv2" alt=""><figcaption></figcaption></figure>

**AR.IO is the bridge between the permanent web and the real world.**

Built on top of [Arweave](https://www.arweave.org/), a blockchain designed for permanent data storage, AR.IO powers the crucial infrastructure that lets decentralized apps (dApps) send and retrieve data, reliably and forever.

By creating decentralized, incentivized gateways, AR.IO makes it easy for developers and users to interact with Arweave’s permaweb. Whether it’s archiving history, hosting unstoppable apps, or building the next era of open data, AR.IO ensures the flow of information never stops.

Welcome to the future of the internet — where data lives forever.

## Key Features <a href="#id-7716" id="id-7716"></a>

* ***Sustainable, Permanent Storage:***\
  Arweave is a Layer 1 blockchain built for data permanence. Its endowment-based tokenomics incentivize miners to replicate data for centuries — no renewals needed.
* ***Open Protocol for the Permaweb:***\
  AR.IO powers the permawe&#x62;**,** a censorship-resistant layer of files, sites, and apps fixed forever on Arweave. The network is ownerless, run by gateway operators, developers, and users worldwide.
* ***Incentivized Gateway Network:***\
  Gateways are the doorway in and out of Arweave. AR.IO keeps them honest (and growing) with the ARIO token for staking, fee payments, and performance incentives.

> Website : <https://ar.io/>
>
> Twitter : <https://x.com/ar_io_network>
>
> Discord : <https://discord.com/invite/bnNxXRFRkp>
>
> Official Docs : <https://docs.ar.io/>
>
> Official Gateway : <https://gateways.ar.io/#/staking>


# Installation

**Step 1: Update system and install dependencies**

```
sudo apt update -y && sudo apt upgrade -y && sudo apt install -y curl openssh-server git certbot nginx sqlite3 build-essential && sudo systemctl enable ssh && curl -sSL https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add - && echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list && sudo apt-get update -y && sudo apt-get install -y yarn && curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash && source ~/.bashrc && sudo ufw allow 22 80 443 && sudo ufw enable
```

**Step 2: Install Docker**&#x20;

```php
# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
```

```
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

**Step 3:** Install Node Version Manager

```php
nvm install 20.11.1 && nvm use 20.11.1
```

**Step 4: Clone ar.io repository**

```php
git clone -b main https://github.com/ar-io/ar-io-node
cd ar-io-node
```

**Step 5:** Modify your *.env*

```php
GRAPHQL_HOST=arweave.net
GRAPHQL_PORT=443
START_HEIGHT=0
RUN_OBSERVER=true
ARNS_ROOT_HOST=<your-domain>
AR_IO_WALLET=<your-gateway-wallet-address>
OBSERVER_WALLET=<hot-wallet-public-address(you can use same wallet)>
AO_CU_URL=https://cu.ardrive.io
ARNS_NAME_LIST_CACHE_MISS_REFRESH_INTERVAL_SECONDS=60 
```

{% hint style="success" %}
Note : Export your wallet from wander and place in the wallets directory (your\_wallet.json).
{% endhint %}

**Step 6:** Edit DNS Records on Cloudflare.

<figure><img src="/files/78dd2idAm7QAL9GB14K2" alt=""><figcaption></figcaption></figure>

{% hint style="success" %}
Don’t forget to change *“Type”* and switch off “*Proxy”.*
{% endhint %}

**Step 7:** Get *acme\_challange* token for DNS Records.

```
sudo certbot certonly --manual --preferred-challenges dns --email <your-email-address> -d <your-domain> -d '*.<your-domain>'
```

{% hint style="success" %}
Note : Change email by your email and domain by your domain.
{% endhint %}

**Step 8:** Configure nginx on Server

```
sudo nano /etc/nginx/sites-available/default
```

```
# Force redirects from HTTP to HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name <your-domain>.com *.<your-domain>;

    location / {
        return 301 https://$host$request_uri;
    }
}

# Forward traffic to your node and provide SSL certificates
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    server_name <your-domain> *.<your-domain>;

    ssl_certificate /etc/letsencrypt/live/<your-domain>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<your-domain>/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_http_version 1.1;
    }
}
```

```
sudo nginx -t
```

{% hint style="success" %}
There'll be **ok** status if all nginx settings was correct.
{% endhint %}

```
sudo service nginx restart
```

**Step 9:** Run the node

```
sudo docker compose up -d
```

**Step 10:** Stop the node

```
sudo docker compose down
```


# Cheatsheet

**Node Management**

1. Start the Docker container :&#x20;

```
sudo docker compose up -d
```

2. Stop the Docker :&#x20;

```
sudo docker compose down
```

3. Check logs node :&#x20;

```
sudo docker compose logs -f --tail=0
```

4. Update node to the newest :&#x20;

```
cd ~/ar-io-node
sudo docker compose down
git checkout main
git pull
sudo docker compose up -d
```

5. Downgrade to the specifiead version :&#x20;

```
cd ~/ar-io-node
git checkout r29
docker compose down
docker compose up -d --build

#note : change r29 to any specified version
```

6. Check verion node :&#x20;

```php
curl http://localhost:3000/ar-io/info | jq
```

7. Test node

```php
 https://<your-domain>/3lyxgbgEvqNSvJrTX2J7CfRychUD5KClFhhVLyTPNCQ in your browser.
```

**Troubleshooting**

1. Insufficient balance when Observing.

<figure><img src="/files/CJrC5N94sOMdZpxlvsBF" alt=""><figcaption></figcaption></figure>

> Solution : You need to top up Turbo Balance on Observer Wallet
>
> \
> Step : \
> \# Go to this website -> <https://turbo-topup.com/>\
> \## Connect with your Observer wallet\
> \### Buy Credit -> You can use USD / AR\
> \#### 0.5 AR or equal is enough


# Staking

### Buy $ARIO and Setting Gateway <a href="#a8f1" id="a8f1"></a>

1\. Buy Minimum 10k $ARIO to setup Gateway, you can use Cex like [*Gate.io*](https://www.gate.io/signup/UAQRUFwN?ref_type=102) and for DeFi on Arweave Ecosystem you can use [*Permaswap* ](https://www.permaswap.network/#/ao/0syT13r0s0tgPmIed95bJnuSqaD29HQNN8D3ElLSrsc%26qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE?tab=swap)or [*Botega*](https://botega.arweave.net/#/swap?from=0syT13r0s0tgPmIed95bJnuSqaD29HQNN8D3ElLSrsc\&to=qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE).

<figure><img src="/files/0VMaDdJjjDEJLtRG2I7V" alt=""><figcaption></figcaption></figure>

2. Setting up your Gateway by staking $ARIO and use your [*domain name*](/mainnet-node/ar.io/domain) .

<figure><img src="/files/ade3cRkxc96b2ed6DmSK" alt=""><figcaption></figcaption></figure>

> Note :\
> 1\. Label : your desired node name / moniker\
> 2\. Address : your domain was purchased before\
> 3\. Stake : Minimum 10000 ARIO\
> 4\. Minimum Delegated Stake : Minimum user can stake to your Gateway\
> 5\. Reward Share Ratio : How much you would share Gateway rewards to staker


# Domain

### **Buy domain and manage on Cloudflare** <a href="#fe7c" id="fe7c"></a>

1\. You can use any domain registrar (*Namecheap* , [***Hostinger***](https://niagahoster.co.id/?REFERRALCODE=LOGOSNODOS) *or etc)*.

<figure><img src="/files/h08Jz8ndsRhnu8jKgTwJ" alt=""><figcaption></figcaption></figure>

2\. After successfully buy domain you need to change DNS to Cloudflare.

* **Log In to Your Cloudflare Account**\
  Go to your Cloudflare Dashboard and click the **“Add a domain”** button on your homepage.
* **Enter Your Existing Domain**\
  Type your current domain (e.g., `yourdomain.com`) and choose the **“Quick scan”** option to automatically detect existing DNS records.
* **Copy Cloudflare’s Nameservers**\
  Once the scan is complete, Cloudflare will provide two nameservers. Copy both of them.
* **Update Nameservers on Your Domain Provider (e.g., Namecheap)**\
  Log in to your domain provider’s dashboard, go to the **DNS / Nameservers** section, and replace the existing nameservers with the ones from Cloudflare. Save the changes.

> \>>> Example:\
> From `dns1.namecheap.com` → change to `ns1.cloudflare.com`

* **Wait for DNS Propagation**\
  DNS changes usually take about **30–60 minutes** to update, but sometimes up to 24 hours. Once done, your domain will appear in your Cloudflare dashboard and will be ready to manage.&#x20;


# BlockX

Stake with LOGOSNODOS

{% embed url="<https://explorer.vinjan.xyz/blockx-mainnet/staking/blockxvaloper169ee3kvyvf9nl46gd0nc3s4jlrsszs4zg9xkhs>" %}

RPC :&#x20;

```
```

API :&#x20;

```
```

<figure><img src="/files/x5e1My5nv2PQYsMYXHrS" alt=""><figcaption></figcaption></figure>

BlockX Network is a Layer 1 Ethereum alternative blockchain that offers multi-chain operability, an off-chain oracle infrastructure, and enables sovereign digital identity for the next-gen of Web3.


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: blockx\_100-1 | **Latest Version Tag**: - | **Wasm**: -

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export WALLET="YOUR WALLET"" >> $HOME/.bash_profile
echo "export MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export BLOCKX_CHAIN_ID="blockx_100-1"" >> $HOME/.bash_profile
echo "export BLOCKX_PORT="22"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
git clone https://github.com/BlockXLabs/BlockX-Genesis-Mainnet1.git
cd BlockX-Genesis-Mainnet1
git checkout 
make install
```

Set custom ports

```
CUSTOM_PORT=22
sed -i.bak -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}658\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}657\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}060\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}656\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}660\"%" $HOME/.blockxd/config/config.toml
sed -i.bak -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}317\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}080\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}090\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}091\"%; s%^address = \"127.0.0.1:8545\"%address = \"0.0.0.0:${CUSTOM_PORT}545\"%; s%^ws-address = \"127.0.0.1:8546\"%ws-address = \"0.0.0.0:${CUSTOM_PORT}546\"%" $HOME/.blockxd/config/app.toml
```

#### Set seeds & peers

```
PEERS="baa8b43f6208e330cb37156ecf3b2523766f8012@116.202.218.189:20656,85d0069266e78896f9d9e17915cdfd271ba91dfd@146.190.153.165:26656,e15f4d31281036c69fa17269d9b26ff8733511c6@147.182.238.235:26656,dc240d568509fa275cb870b93de4db1869d7187a@5.78.103.187:26656,8ebf5e70dad7268a66a9198dbe9006f9140415b6@217.182.211.81:26656,bc152258668e673a3b63f964fa75afdd478078c7@185.246.85.48:39656,72639ce4ce7e0260d7ae129e6acc07dcb54d6af1@167.235.102.45:20656,bbe679ddc774dc91b962985c7339a2e7934b8451@207.180.250.5:26656,203082daff197dca66797d955d103740875d84d8@2a01:4f9:3051:19c2::2:4f9,49d33c76a5b47e86f04695752f8be45e7b148bf1@65.109.115.56:38656,d2c3dbb7bcf808253f8d8b42fed4a90f7e4e0004@2a01:4f9:3081:4e45::3:4f9,9b84b33d44a880a520006ae9f75ef030b259cbaf@137.184.38.212:26656,e1a613fcc3c141c2235ce68edea4e765a3eb3c92@51.161.86.217:24127,c178426ed905a7074b44fca4867f2d324923b9e2@143.198.142.220:14356,479dfa1948f49b08810cd16bf6c2d3256ae85423@137.184.7.64:26656,66fccb6e7953e644ae61f974464a3716318a3275@54.211.219.127:26656,adcd9c90cc9fba509fb283e365ecd31bd5c37ff5@49.13.166.213:26656,3b8c6110d563abd71519aad5c7b27e5f844f120e@142.44.213.82:1340,c811a29fd53d393798b099fe69b056074043ba7d@65.109.52.56:32338,8cd5f922e33c7b6b4d930592c8c0663bc59c435e@103.97.111.34:26656,ce231e664fc8457893d3f94fb4e4631582ddddcd@194.163.183.175:26656,136396a99ee03cb823b4e08103411aeb12ee0131@34.135.218.59:26656,1a3ab3e87fbf63d06eacf8031671fe60f117eba6@65.109.154.181:36656,1d8945e8c77ea3a8d448c7fe77adef4088458af4@37.27.58.244:23656,42276c994042cca25c6847774cd013abffd1358d@161.35.234.101:26656,417186439f227bf16b4ced80c0486dd85c6c9d95@65.108.76.33:17656,521e01316a7afc5e9ba7322abb1a4ad10a7487b0@167.71.208.139:26656,34d08633547fc406095ff6d730fdfe65d34b96d0@158.69.125.73:11356,97b3e48102de1f6535b9b1d870ec91b64967576f@95.217.207.236:22156,4980cd150a8d9baae6f274f4138d3fb8a2b52bf3@51.159.56.248:21868,e8d1427b1939f3549a875ccf848a90a08d81de25@164.92.102.139:14356,f55751c79576d7ed66ebb77fce02c9f925cd4010@135.181.227.157:14356,0da0557fba17c436deb849cb394580ea79272c62@64.23.170.83:14356,1cd9aa655dc6e2d4e6eb266354950f86a203d41c@176.9.45.69:22156,5fcc83946e0a8586a2092230cc796a9296847155@144.91.64.71:14356,0c176c5828a43ad06127a64cd6fe1e54ebc795f2@51.91.215.27:26656,33b5d53a86ef170bc61718517bfd9b3668c1fe37@65.108.87.60:26656,5cdc5f599b1ca26a7978a0ff08b3e5dfc63380a9@65.21.88.86:36656,0c15ddc0602839dd3aa72217c71b16e278f45d13@148.251.23.39:26656,f3f2a5a562c64442847968fa5c8a3e5876d9fa4d@192.99.160.197:16656,051c15cab838df780c49605bbebcf33eadfaee99@167.235.39.5:60656,9e23d825a06cf0a5564f6251de82da52ea665d91@165.154.252.210:26656,5750c68c6a9b4ad5c89f19d423441ce95b61835c@176.57.184.146:45656,8c3622f9a77710185c057ed51c579784a0785e5a@167.235.12.38:29156,f42e54e739a25cafb88ebe6593e13ee57f613007@136.243.104.103:12256,9bb9207e52b2d46b0bc69ae3ecd863efd3380ca6@65.108.232.168:39656,f2114d9a9937c46771e79cc3054b43e5c62dd0c6@65.21.184.104:26656,aea10542932c383942e4bd3e5d2118e2a67cc0a7@65.21.90.140:4f9,75562a1126b60c92fa0b80727603e538d8a3b940@104.43.108.67:26656,7c7cac0778676664626768619cbb1c9b9d65cb5a@95.217.105.34:4f9,103a7420b3dba4ebae71ad73932d803bf02790e8@46.250.226.146:14356,68e0c04e32741ccf10e7fdf02bb72156c4596ced@37.27.48.156:22156,e56cc72b6f947c78c29611f567bf359e6ab450d9@65.109.153.140:16607,5611e502ae2aff6f8c7758f465ae5db82d12420b@95.216.43.190:26656,28790040b3412ead0ea43a9bd64c1e470d175da6@46.4.64.123:26656,4c9eb47a391ef4434bbb7eaf7fa921d156344698@65.21.198.100:12256,540af05d0763ef457b84c69b7beb363b9c53f1e5@178.162.165.193:26656,dfc2886dd41cc063ac0e962df490e94bc4aa6e43@65.108.206.74:19656,4580170247ae7918c3c5a087632278f8004dee96@158.220.117.55:26661,ed5384bd984a04f19aeb7e17699c061bffd16c41@88.99.59.227:11632,5cb265623b9297748be84b7030d5f9f5a3ce2296@194.163.167.138:48656,a5630759361803d0fa5e3c24658075a016374554@94.130.220.233:19656,056a8ddf9c8e8b9577e582a4fe7d82f2e931fdf7@84.46.245.222:27656,0a71ab602acf7b13a7c843a8d08b1460babe8f7d@93.123.118.50:26656,91c24aac8da5df96435b2af2984a6a5b5b00b54e@46.38.232.86:6969,df949a46ae6529ae1e09b034b49716468d5cc7e9@185.221.152.32:12856"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" $HOME/.blockxd/config/config.toml
sed -i -e "s|^seeds *=.*|seeds = \"\"|" $HOME/.blockxd/config/config.toml
```

#### Config pruning

```
pruning="custom"
pruning_keep_recent="100"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.blockxd/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.blockxd/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.blockxd/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.blockxd/config/app.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/blockxd.service > /dev/null << EOF
[Unit]
Description=blockxd
After=network-online.target

[Service]
User=$USER
ExecStart=$(which blockxd) start --home $HOME/.blockxd
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable blockxd
sudo systemctl restart blockxd
sudo journalctl -fu blockxd -o cat
```


# Cheat Sheet

## Key management

#### Add new key

```
blockxd keys add $WALLET
```

#### Recover existing key

```
blockxd keys add $WALLET --recover
```

#### List all keys

```
blockxd keys list
```

#### Delete key

```
blockxd keys delete $WALLET
```

#### Export key to the file

```
blockxd keys export $WALLET
```

#### Import key from the file

```
blockxd keys import $WALLET wallet.backup
```

#### Query wallet balance

```
blockxd q bank balances $(quicksilverd keys show $WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
blockxd tx staking create-validator \
--amount=1000000000000000000abcx \
--moniker="YOUR MONIKER" \
--pubkey=$(blockxd tendermint show-validator) \
--identity="IDENTITY KEYBASE" \
--details="DETAILS VALIDATOR" \
--website="LINK WEBSITE" \
--security-contact=CONTACT \
--chain-id=blockx_100-1 \
--commission-rate=0.07 \
--commission-max-rate=0.20 \
--commission-max-change-rate=0.07 \
--min-self-delegation=1 \
--from=wallet \
--gas="1000000" \
--gas-prices="10000000000abcx"
```

#### Edit existing validator

```
blockxd tx staking edit-validator \
--new-moniker="YOUR MONIKER" \
--identity="IDENTITY KEYBASE" \
--details="DETAILS VALIDATOR" \
--website="LINK WEBSITE" \
--security-contact=CONTACT \
--chain-id=blockx_100-1 \
--commission-rate=0.07 \
--from=wallet \
--gas="1000000" \
--gas-prices="10000000000abcx"
```

#### Unjail validator

```
blockxd tx slashing unjail --broadcast-mode=block --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Jail reason

```
blockxd q slashing signing-info $(blockxd tendermint show-validator)
```

#### List all active validators

```
blockxd q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
blockxd q staking validator $(blockxd keys show wallet --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
blockxd tx distribution withdraw-all-rewards --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Withdraw commission and rewards from your validator

```
blockxd tx distribution withdraw-rewards $(blockxd keys show wallet --bech val -a) --commission --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Delegate tokens to yourself

```
blockxd tx staking delegate $(blockxd keys show wallet --bech val -a) 1000000000000000000abcx --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Delegate tokens to validator

```
blockxd tx staking delegate  1000000000000000000abcx --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Redelegate tokens to another validator

```
blockxd tx staking redelegate $(blockxd keys show wallet --bech val -a)  1000000000000000000abcx --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Unbond tokens from your validator

```
blockxd tx staking unbond $(blockxd keys show wallet --bech val -a) 1000000000000000000abcx --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Send tokens to the wallet

```
blockxd tx bank send wallet  1000000000000000000abcx --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

***

## Governance

#### List all proposals

```
blockxd query gov proposals
```

#### View proposal by id

```
blockxd query gov proposal 1
```

#### Vote 'Yes'

```
blockxd tx gov vote 1 yes --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Vote 'No'

```
blockxd tx gov vote 1 no --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Vote 'Abstain'

```
blockxd tx gov vote 1 abstain --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

#### Vote 'NoWithVeto'

```
blockxd tx gov vote 1 nowithveto --from wallet --chain-id blockx_100-1 --gas="1000000" --gas-prices="30000000000abcx"
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=22
sed -i.bak -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}658\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}657\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}060\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}656\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}660\"%" $HOME/.blockxd/config/config.toml
sed -i.bak -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}317\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}080\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}090\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}091\"%; s%^address = \"127.0.0.1:8545\"%address = \"0.0.0.0:${CUSTOM_PORT}545\"%; s%^ws-address = \"127.0.0.1:8546\"%ws-address = \"0.0.0.0:${CUSTOM_PORT}546\"%" $HOME/.blockxd/config/app.toml
```

#### Update Indexer

**Disable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "null"|' $HOME/.blockxd/config/config.toml
```

**Enable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "kv"|' $HOME/.blockxd/config/config.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
blockxd status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
blockxd status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(blockxd tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.blockx/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(blockxd q staking validator $(blockxd keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
blockxd tendermint unsafe-reset-all --keep-addr-book --home $HOME/.sge --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop blockxd && \
sudo systemctl disable blockxd && \
rm /etc/systemd/system/blockxd.service && \
sudo systemctl daemon-reload && \
cd $HOME && \
rm -rf .blockxd && \
rm -rf $(which blockxd)
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable blockxd
```

#### Disable service

```
sudo systemctl disable blockxd
```

#### Start service

```
sudo systemctl start blockxd
```

#### Stop service

```
sudo systemctl stop blockxd
```

#### Restart service

```
sudo systemctl restart blockxd
```

#### Check service status

```
sudo systemctl status blockxd
```

#### Check service logs

```
sudo journalctl -u blockxd-f --no-hostname -o cat
```


# Muon Network

<figure><img src="/files/mV02DnaiX1xGXsdb0Dc6" alt=""><figcaption></figcaption></figure>

MUON NETWORK A Decentralized Optimistic Oracle Network

Website : <https://www.muon.net/>

Twitter : <https://twitter.com/muon_net>

Discord : <https://discord.com/invite/rcK4p8g7Ce>

**Telegram :** <https://t.me/muon_net>

**Medium :** <https://medium.com/muon>

Github : <https://github.com/muon-protocol>


# Installation

Please follow all steps briefly !!!

## 1. Running The Node

* Before installing a Pion node, one needs to install Docker. To do so, you can use [Install Docker Engine](https://docs.docker.com/engine/install/#server), where you should first choose your server's operating system, and then follow the installation instructions.&#x20;
* If you already have an ALICE node and are migrating to Pion, first stop and remove your old node by running the following commands on your server (one by one):

```
docker stop muon-node mongo redis
docker rm muon-node mongo redis
```

* The first step is to get the Pion `docker-compose.yml` . To do so, run the following command on your server:&#x20;

```
curl -o docker-compose.yml https://raw.githubusercontent.com/muon-protocol/muon-node-js/pion/docker-compose-pull.yml
```

* And then you call pull images using this command:

```
docker compose pull
```

* Now the node can be run using the following command.

```
docker compose up -d
```

* Wait for a minute and then run the next command and see the result.&#x20;

```
curl http://localhost:8012/status
```

{% hint style="info" %}
The result should look like this and means your node is running properly. (It is not added to the network yet.)\
\
{"address":"0x22E25482F7B27b8765FE93F4ac0Cb79a0e8cB3ef","peerId":"QmVZrfc47AQQoPGjbWAmd1wQv9BtGYpFQ67JnbFmmHxAWN","networkingPort":"9012","node":{"addedToNetwork":false,...}}\
\
You need this `address` and `peerID` later when you add the node to the network.

But if you see the message `curl (7) failed connect to localhost:8012 connection refused` , refer to [this FAQ](broken://pages/G4uAZ7VbC0weTp9HGRnU#when-i-run-curl-http-localhost-8012-status-i-see-this-error-message-curl-7-failed-connect-to-localho).&#x20;
{% endhint %}

***

## 2. Acquiring bonPION

* If you are eligible for the bonPION node-drop, you first need to refer to the [Claim the Node-Drop](broken://pages/a36mKPNC8GKIyeTX0v8s) section and follow the steps. Having claimed it, move on to [section 3](#3-adding-the-node-to-the-network) on this page.
* If you are a new user, you need to refer to [Pion dashboard](https://app.muon.net/pion/getting-started) and click on Buy Pion. Follow the steps through.

<figure><img src="/files/FWHBRibPwRbuCK9BwztY" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
To run a tier1 node, you need at least 500 bonPIONs. Having bought that, click on the  "Create Bonded Pion" to create your NFT. Then move on to [section 3](#3-adding-the-node-to-the-network) on this page.

<mark style="color:orange;">**NB:**</mark> Having created your bonPION, you can [boost your NFT](https://docs.muon.net/muon-network/muon-nodes/pion/upgrading-bonpion-nfts) to earn higher rewards.&#x20;
{% endhint %}

***

## 3. Adding the Node to the Network

* After you have gone through the steps in sections 1 & 2, refer to [Pion dashboard](http://app.muon.net/pion/getting-started). connect your wallet and click on "Set up Node".

<figure><img src="/files/8pbYKWDlylYPUQ72R8Ob" alt=""><figcaption></figcaption></figure>

* Your are forwarded to the next page. Click on "Select".

<figure><img src="/files/EN8IX0GLkFaUuvOOva53" alt=""><figcaption></figcaption></figure>

* A popup opens showing the amount of your bonPION. Click on the popup.

<figure><img src="/files/helbbVlqe3vVtL3y366o" alt=""><figcaption></figcaption></figure>

* On the next page, you can see your NFT info in the left-hand box. In the right-hand one, enter your Node Address and Peer ID (explained in section 1).

<figure><img src="/files/0lE7RMUCMxWJ6E1r75FQ" alt=""><figcaption></figcaption></figure>

* Having entered Node Address and Peer ID, click on the "Approve" and confirm the message on your wallet. Now the "Add Node" button appears. Click on it and confirm the transaction on your wallet.

<figure><img src="/files/21dvJKBPrm3BWWN2eOYF" alt=""><figcaption></figcaption></figure>

* Wait for the success message in the right-hand bottom corner.&#x20;

<figure><img src="/files/o0E6cdlYaJba2UangGgO" alt=""><figcaption></figcaption></figure>

* Having added the node successfully, you will see the following page for a few minutes.&#x20;

<figure><img src="/files/4kwTQs917lEfu1pJ0JV4" alt=""><figcaption></figcaption></figure>

* When you see the following dashboard, you have successfully joined Pion network.

<figure><img src="/files/NULnMG3MWJPewuH7tHHj" alt=""><figcaption></figcaption></figure>

{% hint style="danger" %} <mark style="color:orange;">**VERY IMPORTANT**</mark>: Make sure you have [backed up your node](broken://pages/pBHPl7NYsatb7ZPE8MA7) as soon as you add it. In case something happens to your server, you can use the backup to restore your node. Not backing up your node may result in financial loss.
{% endhint %}

* Now you should go through [uniqueness verification](broken://pages/Krf9sANhPs6R5v90pIRh) and register your node with the [Pion Nodes bot](broken://pages/p0NV0xrjdKDUHJHbUYUd) on Muon Discord channel.&#x20;


# Troubleshooting

#### When I run `curl http://localhost:8012/status`,  I see this error message `curl (7) failed connect to localhost:8012 connection refused`. What should I do?

```
sudo ufw reset
sudo ufw allow 8012/tcp
sudo ufw allow 9012/tcp
```

Now run the `curl http://localhost:8012/status` again and the problem is solved. However, if you still see the error message, contact our support team on [Discord](https://discord.com/channels/830888887253073920/1065565092151820308)/[Telegram](https://t.me/muon_net).


# RaiblocksOne

<figure><img src="/files/zS0p2yjinrtFiTRZCYN3" alt=""><figcaption></figcaption></figure>

Instant and feeless transactions with RaiblocksOne - a fork of Nano. Rewards for being a Principal Representative incentivize community commitment.

Website: <https://raione.cc/> \
Wallet: <https://vault.raione.cc/> \
Explorer: <https://explorer.raione.cc/> \
Faucet1: <https://nanswap.com/raiblocks1-faucet> \
Faucet2: <https://monke42.tk/> \
Faucet3: <https://faucet-xro.codeblocklabs.com/> \
FAQs: <https://raione.cc/faq>&#x20;

\
Whitepaper: <https://raione.cc/whitepaper> \
Roadmap: <https://raione.cc/roadmap> \
Reddit: <https://reddit.com/r/raiblocksone> \
Twitter: <https://twitter.com/raiblocksone> <br>

Exchanges: Nanswap <https://nanswap.com/>

Games: Nanbet (Rock, Paper, Scissors) <https://nanbet.io/>

Ledger Download: <https://drive.google.com/file/d/1QJBfMm0G_2n918c77tngsu7qMVvHY1GI/view?usp=sharing> \
Logo Download: <https://drive.google.com/drive/folders/1AKRsltWCj8qi-kgkbUBeV7Njs8ybH9ON>


# Installation

Please follow all steps briefly !!!

<table><thead><tr><th width="166">Requirements</th><th>Minimum</th><th>Recomended</th></tr></thead><tbody><tr><td>CPU</td><td>Core 2+</td><td></td></tr><tr><td>RAM</td><td>4GB+</td><td></td></tr><tr><td>STORAGE</td><td>120GB+ SSD/NVME</td><td></td></tr></tbody></table>

{% hint style="info" %}
Before installing a RaiblocksOne node, one needs to install Docker. To do so, you can use [Install Docker ](https://docs.docker.com/engine/install/#server)
{% endhint %}

* Update and Install Dependencies

```
apt update -y &&
apt upgrade -y && 
apt autoremove -y && 
apt install screen curl -y
```

* Pull image from the docker&#x20;

```
docker pull raiblocksone/raione:R1_V.02
```

* Run the node once, so you can make a setting file

```
docker run --restart=unless-stopped -d -p 7075:7075 -p 127.0.0.1:7076:7076 -p 127.0.0.1:7078:7078 -v /root/raiblocksone/:/root --name <your docker name> raiblocksone/raione:R1_V.02 
```

* Now stop the node to configure some settings

```
docker stop <your docker name>
```

* Open the config-node.toml file&#x20;

```
sudo nano raiblocksone/Nano/config-node.toml
```

* Copy this code below and place it on the top command

```
[node]

enable_voting = true
```

* Change RPC setting (change enable-control = true)

```
sudo nano raiblocksone/Nano/config-rpc.toml
```

* Restart the node

```
docker restart <your docker name>
```

{% hint style="success" %}
**Useful Command**

*Check Version:*  curl -g -d '{ "action": "version"}' 'localhost:7076'

*Block Count*: curl -g -d '{ "action": "block\_count"}' 'localhost:7076'

*Create New Wallet ID:* curl -g -d '{ "action": "wallet\_create"}' 'localhost:7076'\
*Create New Wallet Account:* curl -g -d '{ "action": "account\_create", "wallet": "%WALLET\_ID% "}' 'localhost:7076'
{% endhint %}


# Cheat Sheet

Check node version

```
curl -d '{"action": "version"}' localhost:7076
```

Check sync status

```
curl -d '{"action": "block_count"}' localhost:7076
```

Create new node Wallet\_ID

```
curl -g -d '{ "action": "wallet_create"}' localhost:7076
```

Import Wallet to the Nodes

```
curl -g -d '{ "action": "wallet_change_seed", "wallet": "YOUR_NODES_WALLET_ID", "seed": "YOUR_SEED_64char"}' localhost:7076
```

For more commands are available in official nano pages : <https://docs.nano.org/commands/rpc-protocol/>

***

## BACKUP WALLET

Go to your docker container

```
docker exec -it raione-node /bin/bash 
```

Use Command below to get your SEED and Private Key

```
/usr/bin/./nano_node --wallet_decrypt_unsafe --wallet=%YOUR_WALLLET_ID%
```

{% hint style="info" %}
Don't forget to change the %YOUR\_WALLLET\_ID%&#x20;
{% endhint %}


# SGE Network

Stake with LOGOSNODOS

{% embed url="<https://ping.pub/sge/staking/sgevaloper1gdj5e9203wmk44rxmf87p3fdmzajresm6trgmd>" %}

RPC :&#x20;

```
rpc.sge.logosnodos.me
```

API :&#x20;

```
api.sge.logosnodos.me
```

<figure><img src="/files/STh5RTo5Xbmc1kfU2T2b" alt=""><figcaption></figcaption></figure>

SIX SIGMA SPORTS combines the best of DeFi innovation and COSMOS scalability to create a user-driven marketplace for sports betting.

Website : [https://sixsigmasports.io](https://sixsigmasports.io/)

Twitter : <https://twitter.com/SixSigmaSports>

Discord : <https://discord.gg/bmNuymDvsZ>

**Telegram :** <https://t.me/SixSigmaSports>&#x20;

**Medium :** <https://t.co/qAnCnzngwQ>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: sgenet-1 | **Latest Version Tag**: v1.1.1 | **Wasm**: OFF

### Peering

**seed-node**

```
6a727128f427d166d90a1185c7965b178235aaee@rpc.sge.nodestake.top:666,e752327338c0141b946ec54f85d51f450c4ad643@46.250.237.163:26656
```

## Installation

**Chain ID**: sgenet-1 | **Latest Version Tag**: v1.1.1 |

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Download and build binaries**

```
cd $HOME
rm -rf sge
git clone https://github.com/sge-network/sge
cd sge
git checkout v1.1.1
make install
sged version
```

**Initialize Node & Genesis**

```
# Change Moniker
sged init <Moniker> --chain-id=sgenet-1
```

**Download Genesis**

```
curl -Ls wget https://offellnode.s3.ap-southeast-1.amazonaws.com/sge/genesis.json > $HOME/.stchaind/config/genesis.json 
```

#### Create a service

```
sudo tee /etc/systemd/system/sged.service > /dev/null <<EOF
[Unit]
Description=sged Daemon
After=network-online.target
[Service]
User=$USER
ExecStart=$(which sged) start
Restart=always
RestartSec=3
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable sged
```

#### Initialize the node

```
# Set node configuration
sged config chain-id sgenet-1
sged config keyring-backend file

# Add seeds
sed -i -e "s|^seeds *=.*|seeds = \"6a727128f427d166d90a1185c7965b178235aaee@rpc.sge.nodestake.top:666,e752327338c0141b946ec54f85d51f450c4ad643@46.250.237.163:26656\"|" $HOME/.sge/config/config.toml

# Set minimfum gas price
sed -i -e "s|^minimum-gas-prices *=.*|minimum-gas-prices = \"0.025usge\"|" $HOME/.sge/config/app.toml

# Set pruning
sed -i \
  -e 's|^pruning *=.*|pruning = "custom"|' \
  -e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
  -e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
  -e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
  $HOME/.sge/config/app.toml
```

#### Start service and check the logs

```
sudo systemctl start sged && sudo journalctl -u sged -f --no-hostname -o cat
```


# Cheat Sheet

## Key management

#### Add new key

```
sged keys add wallet
```

#### Recover existing key

```
sged keys add wallet --recover
```

#### List all keys

```
sged keys list
```

#### Delete key

```
sged keys delete wallet
```

#### Export key to the file

```
sged keys export wallet
```

#### Import key from the file

```
sged keys import wallet wallet.backup
```

#### Query wallet balance

```
sged q bank balances $(sged keys show wallet -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity**, **details** and **website** to match your values.
{% endhint %}

#### Create new validator

```
sged tx staking create-validator \
--amount=1000000usge \
--moniker="YOUR MONIKER" \
--pubkey=$(sged tendermint show-validator) \
--identity="IDENTITY KEYBASE" \
--details="DETAILS VALIDATOR" \
--website="LINK WEBSITE" \
--security-contact=CONTACT \
--chain-id=sgenet-1 \
--commission-rate=0.07 \
--commission-max-rate=0.20 \
--commission-max-change-rate=0.07 \
--min-self-delegation=1 \
--from=wallet \
--gas-adjustment="1.4" \
--fees="5000usge"
```

#### Edit existing validator

```
sged tx staking edit-validator \
--new-moniker "YOUR_MONIKER_NAME" \
--identity "YOUR_KEYBASE_ID" \
--details "YOUR_DETAILS" \
--website "YOUR_WEBSITE_URL" \
--chain-id sgenet-1 \
--commission-rate 0.05 \
--from wallet \
--gas-adjustment 1.4 \
--gas auto \
--gas-prices 5000usge \
-y
```

#### Unjail validator

```
sged tx slashing unjail --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Jail reason

```
sged query slashing signing-info $(sged tendermint show-validator)
```

#### List all active validators

```
sged q staking validators -oj --limit=3000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " \t " + .description.moniker' | sort -gr | nl
```

#### List all inactive validators

```
sged q staking validators -oj --limit=3000 | jq '.validators[] | select(.status=="BOND_STATUS_UNBONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " \t " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
sged q staking validator $(sged keys show wallet --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
sged tx distribution withdraw-all-rewards --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 1000000usge -y
```

#### Withdraw commission and rewards from your validator

```
sged tx distribution withdraw-rewards $(sged keys show wallet --bech val -a) --commission --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 1000000usge -y
```

#### Delegate tokens to yourself

```
sged tx staking delegate $(sged keys show wallet --bech val -a) 10000000usge --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 1000000usge -y
```

#### Delegate tokens to validator

```
sged tx staking delegate <TO_VALOPER_ADDRESS> 1000000usge --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Redelegate tokens to another validator

```
sged tx staking redelegate $(sged keys show wallet --bech val -a) <TO_VALOPER_ADDRESS> 10000000usge --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Unbond tokens from your validator

```
sged tx staking unbond $(sged keys show wallet --bech val -a) 1000000usge --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Send tokens to the wallet

```
sged tx bank send wallet <TO_WALLET_ADDRESS> 1000000usge --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

***

## Governance

#### List all proposals

```
sged query gov proposals
```

#### View proposal by id

```
sged query gov proposal 1
```

#### Vote 'Yes'

```
sged tx gov vote 1 yes --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Vote 'No'

```
sged tx gov vote 1 no --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Vote 'Abstain'

```
sged tx gov vote 1 abstain --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

#### Vote 'NoWithVeto'

```
sged tx gov vote 1 NoWithVeto --from wallet --chain-id sgenet-1 --gas-adjustment 1.4 --gas auto --gas-prices 10000000usge -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.sge/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.sge/config/app.toml
```

#### Update Indexer

**Disable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "null"|' $HOME/.sge/config/config.toml
```

**Enable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "kv"|' $HOME/.sge/config/config.toml
```

#### Update pruning

```
sed -i \
  -e 's|^pruning *=.*|pruning = "custom"|' \
  -e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
  -e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
  -e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
  $HOME/.sge/config/app.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
sged status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
sged status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(sged tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.sge/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(sged q staking validator $(sged keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Set minimum gas price

```
sed -i -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.025usge\"/" $HOME/.sge/config/app.toml
```

#### Enable prometheus

```
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.sge/config/config.toml
```

#### Reset chain data

```
sged tendermint unsafe-reset-all --keep-addr-book --home $HOME/.sge --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
cd $HOME
sudo systemctl stop sged
sudo systemctl disable sged
sudo rm /etc/systemd/system/sged.service
sudo systemctl daemon-reload
rm -f $(which sged)
rm -rf $HOME/.sge
rm -rf $HOME/sge
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable sged
```

#### Disable service

```
sudo systemctl disable sged
```

#### Start service

```
sudo systemctl start sged
```

#### Stop service

```
sudo systemctl stop sged
```

#### Restart service

```
sudo systemctl restart sged
```

#### Check service status

```
sudo systemctl status sged
```

#### Check service logs

```
sudo journalctl -u sged -f --no-hostname -o cat
```


# Quicksilver Protocol

Stake with LOGOSNODOS

{% embed url="<https://mainnet.itrocket.net/quicksilver/staking/quickvaloper1r2fyumjr308wzehlp0uecsxq7v4j7pr3xqprv2>" %}

RPC :&#x20;

```
```

API :&#x20;

```
```

<figure><img src="/files/2h0il0iEtZZ2LBFnqB8t" alt=""><figcaption></figcaption></figure>

QUICKSILVER : THE COSMOS LIQUID STAKING ZONE.

Website : <https://quicksilver.zone/>

Twitter : <https://twitter.com/quicksilverzone>

Discord : <https://discord.com/invite/xrSmYMDVrQ>

**Telegram :** <https://t.me/quicksilverzone>

**Medium :** <https://medium.com/quicksilverzone>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: quicksilver-2 | **Latest Version Tag**: v1.2.17 | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export WALLET="YOUR WALLET"" >> $HOME/.bash_profile
echo "export MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export QUICKSILVER_CHAIN_ID="quicksilver-2"" >> $HOME/.bash_profile
echo "export QUICKSILVER_PORT="15"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
cd $HOME
rm -rf ~/quicksilver
git clone https://github.com/ingenuity-build/quicksilver
cd quicksilver
git fetch
git checkout v1.2.17
make install
```

Set custom ports in app.toml

```
sed -i.bak -e "s%:1317%:${QUICKSILVER_PORT}317%g;
s%:8080%:${QUICKSILVER_PORT}080%g;
s%:9090%:${QUICKSILVER_PORT}090%g;
s%:9091%:${QUICKSILVER_PORT}091%g;
s%:8545%:${QUICKSILVER_PORT}545%g;
s%:8546%:${QUICKSILVER_PORT}546%g;
s%:6065%:${QUICKSILVER_PORT}065%g" $HOME/.quicksilverd/config/app.toml
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${QUICKSILVER_PORT}658%g;
s%:26657%:${QUICKSILVER_PORT}657%g;
s%:6060%:${QUICKSILVER_PORT}060%g;
s%:26656%:${QUICKSILVER_PORT}656%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${QUICKSILVER_PORT}656\"%;
s%:26660%:${QUICKSILVER_PORT}660%g" $HOME/.quicksilverd/config/config.toml
```

#### Config pruning

```
sed -i -e "s/^pruning *=.*/pruning = \"nothing\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"50\"/" $HOME/.quicksilverd/config/app.toml
```

#### Set minimum gas price, enable prometheus and disable indexing

```
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0.0uqck"|g' $HOME/.quicksilverd/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.quicksilverd/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.quicksilverd/config/config.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/quicksilverd.service > /dev/null <<EOF
[Unit]
Description=Quicksilver node
After=network-online.target
[Service]
User=$USER
WorkingDirectory=$HOME/.quicksilverd
ExecStart=$(which quicksilverd) start --home $HOME/.quicksilverd
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable quicksilverd
sudo systemctl restart quicksilverd && sudo journalctl -u quicksilverd -f
```


# Cheat Sheet

## Key management

#### Add new key

```
quicksilverd keys add $WALLET
```

#### Recover existing key

```
quicksilverd keys add $WALLET --recover
```

#### List all keys

```
quicksilverd keys list
```

#### Delete key

```
quicksilverd keys delete $WALLET
```

#### Export key to the file

```
quicksilverd keys export $WALLET
```

#### Import key from the file

```
quicksilverd keys import $WALLET wallet.backup
```

#### Query wallet balance

```
quicksilverd q bank balances $(quicksilverd keys show $WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
quicksilverd tx staking create-validator \
--amount 1000000uqck \
--from $WALLET \
--commission-rate 0.1 \
--commission-max-rate 0.2 \
--commission-max-change-rate 0.01 \
--min-self-delegation 1 \
--pubkey $(quicksilverd tendermint show-validator) \
--moniker "YOUR MONIKER" \
--identity "YOUR KEYBASE ID" \
--details "YOUR DETAILS" \
--chain-id quicksilver-2 \
--fees 100uqck \
-y
```

#### Edit existing validator

```
quicksilverd tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "YOUR MONIKER" \
--identity "YOUR KEYBASE ID" \
--details "YOUR DETAILS" \
--from $WALLET \
--chain-id quicksilver-2 \
--fees 100uqck \
-y
```

#### Unjail validator

```
quicksilverd tx slashing unjail --from $WALLET --chain-id quicksilver-2 --fees 100uqck -y
```

#### Jail reason

```
quicksilverd q slashing signing-info $(quicksilverd tendermint show-validator)
```

#### List all active validators

```
quicksilverd q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
quicksilverd q staking validator $(quicksilverd keys show $WALLET --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
quicksilverd tx distribution withdraw-all-rewards --from $WALLET --chain-id quicksilver-2 --fees 100uqck
```

#### Withdraw commission and rewards from your validator

```
quicksilverd tx distribution withdraw-rewards $VALOPER_ADDRESS --from $WALLET --commission --chain-id quicksilver-2 --fees 100uqck -y
```

#### Delegate tokens to yourself

```
quicksilverd tx staking delegate $(quicksilverd keys show $WALLET --bech val -a) 1000000uqck --from $WALLET --chain-id quicksilver-2 --fees 100uqck -y
```

#### Delegate tokens to validator

```
quicksilverd tx staking delegate YOUR VALOPER ADDRESS 1000000uqck --from $WALLET --chain-id quicksilver-2 --fees 100uqck -y
```

#### Redelegate tokens to another validator

```
quicksilverd tx staking redelegate $VALOPER_ADDRESS YOUR VALOPER ADDRESS 1000000uqck --from $WALLET --chain-id quicksilver-2 --fees 100uqck -y
```

#### Unbond tokens from your validator

```
quicksilverd tx staking unbond $(quicksilverd keys show $WALLET --bech val -a) 1000000uqck --from $WALLET --chain-id quicksilver-2 --fees 100uqck -y
```

#### Send tokens to the wallet

```
quicksilverd tx bank send $WALLET_ADDRESS YOUR WALLET ADDRESS 1000000uqck --fees 100uqck -y
```

***

## Governance

#### List all proposals

```
quicksilverd query gov proposals
```

#### View proposal by id

```
quicksilverd query gov proposal 1
```

#### Vote 'Yes'

```
quicksilverd tx gov vote 1 yes --from $WALLET --chain-id quicksilver-2  --fees 100uqck -y
```

#### Vote 'No'

```
quicksilverd tx gov vote 1 no --from $WALLET --chain-id quicksilver-2  --fees 100uqck -y
```

#### Vote 'Abstain'

```
quicksilverd tx gov vote 1 abstain --from $WALLET --chain-id quicksilver-2  --fees 100uqck -y
```

#### Vote 'NoWithVeto'

```
quicksilverd tx gov vote 1 no_with_veto --from $WALLET --chain-id quicksilver-2  --fees 100uqck -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.sge/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.sge/config/app.toml
```

#### Update Indexer

**Disable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "null"|' $HOME/.sge/config/config.toml
```

**Enable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "kv"|' $HOME/.sge/config/config.toml
```

#### Update pruning

```
sed -i \
  -e 's|^pruning *=.*|pruning = "custom"|' \
  -e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
  -e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
  -e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
  $HOME/.sge/config/app.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
quicksilverd status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
quicksilverd status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(quicksilverd tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.sge/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(quicksilverd q staking validator $(quicksilverd keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
quicksilverd tendermint unsafe-reset-all --keep-addr-book --home $HOME/.sge --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop quicksilverd
sudo systemctl disable quicksilverd
sudo rm -rf /etc/systemd/system/quicksilverd.service
sudo rm $(which quicksilverd)
sudo rm -rf $HOME/.quicksilverd
sed -i "/QUICKSILVER_/d" $HOME/.bash_profile
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable quicksilverd
```

#### Disable service

```
sudo systemctl disable quicksilverd
```

#### Start service

```
sudo systemctl start quicksilverd
```

#### Stop service

```
sudo systemctl stop quicksilverd
```

#### Restart service

```
sudo systemctl restart quicksilverd
```

#### Check service status

```
sudo systemctl status quicksilverd
```

#### Check service logs

```
sudo journalctl -u quicksilverd -f --no-hostname -o cat
```


# 0gchain

Stake with LOGOSNODOS

{% embed url="<https://explorer.validatorvn.com/0g-Testnet/staking/0gvaloper1l45n7449v3ujgun3x4kafvy5czmlt7hczph02h>" %}

RPC :&#x20;

```
https://0gchain-testnet-rpc.logosnodos.me/
```

API :&#x20;

```
https://0gchain-testnet-api.logosnodos.me/
```

<figure><img src="/files/VcccL9p6taKCgtU80kAY" alt=""><figcaption></figcaption></figure>

The first modular AI chain,[@0G\_labs](https://x.com/0G_labs), is coming to define the standards of the combination of AI and blockchain.

**Website :** <https://0g.ai/>

**Twitter :** <https://x.com/0G_labs>

**Discord :** <https://discord.com/invite/0glabs>

**Documentation :** <https://docs.0g.ai/0g-doc>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: zgtendermint\_16600-1 | **Latest Version Tag**:  | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export OGCHAIN_WALLET="YOUR WALLET NAME"" >> $HOME/.bash_profile
echo "export OGCHAIN_MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export OGCHAIN_CHAIN_ID="rhye-1"" >> $HOME/.bash_profile
echo "export OGCHAIN_PORT="23"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
git clone -b v0.1.0 https://github.com/0glabs/0g-chain.git
cd 0g-chain
make install
0gchaind version
```

Set config and init app

```
0gchaind config node tcp://localhost:${QUICKSILVER_PORT}657
0gchaind config keyring-backend os
0gchaind config chain-id rhye-1
0gchaind init "YOUR NODE NAME" --chain-id rhye-1
```

#### Set custom ports in app.toml

```
sed -i.bak -e "s%:1317%:${OGCHAIN_PORT}317%g;
s%:8080%:${OGCHAIN_PORT}080%g;
s%:9090%:${OGCHAIN_PORT}090%g;
s%:9091%:${OGCHAIN_PORT}091%g;
s%:8545%:${OGCHAIN_PORT}545%g;
s%:8546%:${OGCHAIN_PORT}546%g;
s%:6065%:${OGCHAIN_PORT}065%g" $HOME/.0gchaind/config/app.toml
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${OGCHAIN_PORT}658%g;
s%:26657%:${OGCHAIN_PORT}657%g;
s%:6060%:${OGCHAIN_PORT}060%g;
s%:26656%:${OGCHAIN_PORT}656%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${OGCHAIN_PORT}656\"%;
s%:26660%:${OGCHAIN_PORT}660%g" $HOME/.0gchaind/config/config.toml
```

#### Config pruning

```
sed -i -e "s/^pruning *=.*/pruning = \"nothing\"/" $HOME/.0gchaind/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.0gchaind/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"50\"/" $HOME/.0gchaind/config/app.toml
```

#### Set minimum gas price, enable prometheus and disable indexing

```
sed -i "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0ua0gi\"/" $HOME/.0gchain/config/app.toml
sed -i "s/^indexer *=.*/indexer = \"kv\"/" $HOME/.0gchain/config/config.toml
sed -i -e 's/address = "127.0.0.1:8545"/address = "0.0.0.0:8545"/' \
       -e 's/ws-address = "127.0.0.1:8546"/ws-address = "0.0.0.0:8546"/' $HOME/.0gchain/config/app.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/ogd.service > /dev/null <<EOF
[Unit]
Description=OG Node
After=network.target

[Service]
User=root
Type=simple
ExecStart=$(which 0gchaind) start --json-rpc.api eth,txpool,personal,net,debug,web3 --home $HOME/.0gchain
Restart=on-failure
RestartSec=10
LimitNOFILE=65535
Environment="DAEMON_HOME=$HOME/.0gchain"
Environment="DAEMON_NAME=0gchaind"
Environment="UNSAFE_SKIP_BACKUP=true"
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:$HOME/.0gchain/cosmovisor/current/bin"

[Install]
WantedBy=multi-user.target
EOF
```

#### Snapshot

```
sudo systemctl stop ogd
cp $HOME/.0gchain/data/priv_validator_state.json $HOME/.0gchain/priv_validator_state.json.backup
0gchaind tendermint unsafe-reset-all --home $HOME/.0gchain --keep-addr-book
curl https://snapshots-testnet.nodejumper.io/0g-testnet/0g-testnet_latest.tar.lz4 | sudo lz4 -dc - | sudo tar -xf - -C $HOME/.0gchain
mv $HOME/.0gchain/priv_validator_state.json.backup $HOME/.0gchain/data/priv_validator_state.json
sudo systemctl restart ogd && sudo journalctl -u ogd -f -o cat
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable ogd
sudo systemctl restart ogd && sudo journalctl -u quicksilverd -f
```


# Cheat Sheet

## Key management

#### Add new key

```
0gchaind keys add $OGCHAIN_WALLET
```

#### Recover existing key

```
0gchaind keys add $OGCHAIN_WALLET --recover
```

#### List all keys

```
0gchaind keys list
```

#### Delete key

```
0gchaind keys delete $OGCHAIN_WALLET
```

#### Export key to the file

```
0gchaind keys export $OGCHAIN_WALLET
```

#### Import key from the file

```
0gchaind keys import $OGCHAIN_WALLET wallet.backup
```

#### Query wallet balance

```
0gchaind q bank balances $(0gchaind keys show $OGCHAIN_WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
0gchaind tx staking create-validator \
--amount=1000000ua0gi \
--pubkey=$(0gchaind tendermint show-validator) \
--moniker="$MONIKER" \
--chain-id=zgtendermint_16600-1 \
--commission-rate="0.10" \
--commission-max-rate="0.20" \
--commission-max-change-rate="0.01" \
--details="" \
--min-self-delegation="1" \
--from="$OGCHAIN_WALLET" \
--gas=auto \
--gas-adjustment=1.4 \
-y
```

#### Edit existing validator

```
0gchaind tx staking edit-validator \
--new-moniker="YOUR MONIKER" \
--identity="IDENTITY KEYBASE" \
--details="DETAILS VALIDATOR" \
--website="LINK WEBSITE" \
--security-contact=CONTACT \
--chain-id=zgtendermint_16600-1 \
--from=wallet \
--gas=auto \
--gas-adjustment=1.4 \
-y
```

#### Unjail validator

```
0gchaind tx slashing unjail --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --gas auto -y
```

#### Jail reason

```
0gchcaind q slashing signing-info $(0gchaind tendermint show-validator)
```

#### List all active validators

```
0gchaind q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
0gchaind q staking validator $(0gchaind keys show $OGCHAIN_WALLET --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
0gchaind tx distribution withdraw-all-rewards --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --gas auto
```

#### Withdraw commission and rewards from your validator

```
0gchaind tx distribution withdraw-rewards $OGCHAIN_VALOPER_ADDRESS --from $OGCHAIN_WALLET --commission --chain-id zgtendermint_16600-1 --gas auto -y
```

#### Delegate tokens to yourself

```
0gchaind tx staking delegate $(0gchaind keys show $OGCHAIN_WALLET --bech val -a) 1000000ua0gi --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -y
```

#### Delegate tokens to validator

```
0gchaind tx staking delegate YOUR VALOPER ADDRESS 1000000ua0gi --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -
```

#### Redelegate tokens to another validator

```
0gchaind tx staking redelegate $OGCHAIN_VALOPER_ADDRESS YOUR VALOPER ADDRESS 1000000ua0gi --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -
```

#### Unbond tokens from your validator

```
0gchaind tx staking unbond $(0gchaind keys show $OGCHAIN_WALLET --bech val -a) 1000000ua0gi --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -
```

#### Send tokens to the wallet

```
0gchaind tx bank send $WALLET_ADDRESS YOUR WALLET ADDRESS 1000000ua0gi --fees 100ua0gi -y
```

***

## Governance

#### List all proposals

```
0gchaind query gov proposals
```

#### View proposal by id

```
0gchaind query gov proposal 1
```

#### Vote 'Yes'

```
0gchaind tx gov vote 1 yes --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -y
```

#### Vote 'No'

```
0gchaind tx gov vote 1 no --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -y
```

#### Vote 'Abstain'

```
0gchaind tx gov vote 1 abstain --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -y
```

#### Vote 'NoWithVeto'

```
0gchaind tx gov vote 1 no_with_veto --from $OGCHAIN_WALLET --chain-id zgtendermint_16600-1 --fees 100ua0gi -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.0gchain/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.0gchain/config/app.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
0gchaind status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
0gchaind status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(0gchaind tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.0gchain/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(0gchaind q staking validator $(0gchaind keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
0gchaind tendermint unsafe-reset-all --keep-addr-book --home $HOME/.0gchain --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop 0gchaind
sudo systemctl disable 0gchaind
sudo rm -rf /etc/systemd/system/0gchaind.service
sudo rm $(which 0gchaind)
sudo rm -rf $HOME/.0gchaind
sed -i "/OGCHAIN_/d" $HOME/.bash_profile
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable 0gchaind
```

#### Disable service

```
sudo systemctl disable 0gchaind
```

#### Start service

```
sudo systemctl start 0gchaind
```

#### Stop service

```
sudo systemctl stop 0gchaind
```

#### Restart service

```
sudo systemctl restart 0gchaind
```

#### Check service status

```
sudo systemctl status 0gchaind
```

#### Check service logs

```
sudo journalctl -u 0gchaind -f --no-hostname -o cat
```


# Airchains

Stake with LOGOSNODOS

{% embed url="<https://testnet.airchains.io/validator/airvaloper1mugsjk6e553j7ynwm5gyk27wfqcz4qm7je5pqs>" %}

RPC :&#x20;

```
https://airchains-testnet-rpc.logosnodos.me/
```

API :&#x20;

```
https://airchains-testnet-api.logosnodos.me/
```

<figure><img src="/files/yB6iIMuIiyY7IMJ5ApWz" alt=""><figcaption></figcaption></figure>

Seamlessly zk for unmatched speed and privacy with zkRollup Framework, with diverse options for execution and data availability.

**Website :** <https://www.airchains.io/>

**Twitter :** <https://x.com/airchains_io>

**Discord :** <https://discord.com/invite/airchains>

**Documentation :** <https://docs.airchains.io/>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: zgtendermint\_16600-1 | **Latest Version Tag**:  | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export AIRCHAIN_WALLET="YOUR WALLET NAME"" >> $HOME/.bash_profile
echo "export AIRCHAIN_MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export AIRCHAIN_CHAIN_ID="junction"" >> $HOME/.bash_profile
echo "export AIRCHAIN_PORT="33"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
cd $HOME
wget -O junctiond https://github.com/airchains-network/junction/releases/download/v0.1.0/junctiond
chmod +x junctiond
mv junctiond $HOME/go/bin/
```

Set config and init app

```
junctiond init $MONIKER --chain-id $AIRCHAIN_CHAIN_ID 
sed -i -e "s|^node *=.*|node = \"tcp://localhost:${AIRCHAIN_PORT}657\"|" $HOME/.junction/config/client.toml
```

#### Set genesis and address book

```
wget https://github.com/airchains-network/junction/releases/download/v0.1.0/genesis.json
cp genesis.json ~/.junction/config/genesis.json
```

#### Set custom ports in app.toml

```
sed -i.bak -e "s%:1317%:${AIRCHAIN_PORT}317%g;
s%:8080%:${AIRCHAIN_PORT}080%g;
s%:9090%:${AIRCHAIN_PORT}090%g;
s%:9091%:${AIRCHAIN_PORT}091%g;
s%:8545%:${AIRCHAIN_PORT}545%g;
s%:8546%:${AIRCHAIN_PORT}546%g;
s%:6065%:${AIRCHAIN_PORT}065%g" $HOME/.junction/config/app.toml
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${AIRCHAIN_PORT}658%g;
s%:26657%:${AIRCHAIN_PORT}657%g;
s%:6060%:${AIRCHAIN_PORT}060%g;
s%:26656%:${AIRCHAIN_PORT}656%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${AIRCHAIN_PORT}656\"%;
s%:26660%:${AIRCHAIN_PORT}660%g" $HOME/.junction/config/config.toml
```

#### Config pruning

```
sed -i -e "s/^pruning *=.*/pruning = \"custom\"/" $HOME/.junction/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.junction/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"50\"/" $HOME/.junction/config/app.toml
```

#### Set minimum gas price, enable prometheus and disable indexing

```
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0.001amf"|g' $HOME/.junction/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.junction/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.junction/config/config.toml

```

#### Create a service

```
sudo tee /etc/systemd/system/junctiond.service > /dev/null <<EOF

[Unit]
Description=Airchains node
After=network-online.target

[Service]
User=$USER
WorkingDirectory=$HOME/.junction
ExecStart=$(which junctiond) start --home $HOME/.junction
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable junctiond
sudo systemctl restart junctiond && sudo journalctl -u junctiond -f
```


# Cheat Sheet

## Key management

#### Add new key

```
junctiond keys add $AIRCHAIN_WALLET
```

#### Recover existing key

```
junctiond keys add $AIRCHAIN_WALLET --recover
```

#### List all keys

```
junctiond keys list
```

#### Delete key

```
junctiond keys delete $AIRCHAIN_WALLET
```

#### Export key to the file

```
junctiond keys export $AIRCHAIN_WALLET
```

#### Import key from the file

```
junctiond keys import $AIRCHAIN_WALLETwallet.backup
```

#### Query wallet balance

```
junctiond q bank balances $(junctiond keys show $AIRCHAIN_WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
cd $HOME
# Create validator.json file
echo "{\"pubkey\":{\"@type\":\"/cosmos.crypto.ed25519.PubKey\",\"key\":\"$(junctiond comet show-validator | grep -Po '\"key\":\s*\"\K[^"]*')\"},
    \"amount\": \"1000000amf\",
    \"moniker\": \"test\",
    \"identity\": \"\",
    \"website\": \"\",
    \"security\": \"\",
    \"details\": \"\",
    \"commission-rate\": \"0.1\",
    \"commission-max-rate\": \"0.2\",
    \"commission-max-change-rate\": \"0.01\",
    \"min-self-delegation\": \"1\"
}" > validator.json

# Create a validator using the JSON configuration
junctiond tx staking create-validator validator.json \
    --from $AIRCHAIN_WALLET \
    --chain-id junction \
	--fees 200amf \
	
```

#### Edit existing validator

```
junctiond tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "" \
--identity "" \
--details "" \
--from $AIRCHAIN_WALLET \
--chain-id junction \
--fees 200amf \
-y 
```

#### Unjail validator

```
junctiond tx slashing unjail --from $AIRCHAIN_WALLET --chain-id junction --fees 200amf -y 
```

#### List all active validators

```
junctiond q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
junctiond q staking validator $(junctiond keys show $AIRCHAIN_WALLET --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
junctiond tx distribution withdraw-all-rewards --from $WALLET --chain-id junction --fees 200amf 
```

#### Withdraw commission and rewards from your validator

```
junctiond tx distribution withdraw-rewards $VALOPER_ADDRESS --from $WALLET --commission --chain-id junction --fees 200amf -y 
```

#### Delegate tokens to yourself

```
junctiond tx staking delegate $(junctiond keys show $WALLET --bech val -a) 1000000amf --from $WALLET --chain-id junction --fees 200amf -y 
```

#### Delegate tokens to validator

```
junctiond tx staking delegate <TO_VALOPER_ADDRESS> 1000000amf --from $WALLET --chain-id junction --fees 200amf -y 	
```

#### Redelegate tokens to another validator

```
junctiond tx staking redelegate $VALOPER_ADDRESS <TO_VALOPER_ADDRESS> 1000000amf --from $WALLET --chain-id junction --fees 200amf -y 
```

#### Unbond tokens from your validator

```
junctiond tx staking unbond $(junctiond keys show $WALLET --bech val -a) 1000000amf --from $WALLET --chain-id junction --fees 200amf -y 
```

#### Send tokens to the wallet

```
junctiond tx bank send $WALLET_ADDRESS <TO_WALLET_ADDRESS> 1000000amf --fees 200amf -y 
```

***

## Governance

#### List all proposals

```
junctiond query gov proposals
```

#### View proposal by id

```
junctiond query gov proposal 1
```

#### Vote 'Yes'

```
junctiond tx gov vote 1 yes --from $WALLET --chain-id junction  --fees 200amf -y 
```

#### Vote 'No'

```
junctiond tx gov vote 1 no --from $WALLET --chain-id junction  --fees 200amf -y 
```

#### Vote 'Abstain'

```
junctiond tx gov vote 1 abstain --from $WALLET --chain-id junction  --fees 200amf -y 
```

#### Vote 'NoWithVeto'

```
junctiond tx gov vote 1 no_with_veto --from $WALLET --chain-id junction  --fees 200amf -y 
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.junction/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.junction/config/app.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
junctiond status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
junctiond status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(junctiond tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.0gchain/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(junctiond q staking validator $(0gchaind keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
junctiond tendermint unsafe-reset-all --keep-addr-book --home $HOME/.junctiond --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop junctiond 
sudo systemctl disable 0junctiond 
sudo rm -rf /etc/systemd/system/junctiond.service
sudo rm $(which junctiond)
sudo rm -rf $HOME/.junctiond 
sed -i "/AIRCHAIN_/d" $HOME/.bash_profile
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable junctiond 
```

#### Disable service

```
sudo systemctl disable junctiond 
```

#### Start service

```
sudo systemctl start junctiond 
```

#### Stop service

```
sudo systemctl stop junctiond 
```

#### Restart service

```
sudo systemctl restart junctiond 
```

#### Check service status

```
sudo systemctl status junctiond 
```

#### Check service logs

```
sudo journalctl -u junctiond -f --no-hostname -o cat
```


# Avail Network

Stake with LOGOSNODOS

{% embed url="<https://goldberg.avail.tools/#/staking>" %}

<figure><img src="/files/yJl4PDzYxEB9eIWMqXNO" alt=""><figcaption></figcaption></figure>

Avail is a modular blockchain with a data availability layer designed to scale blockchain networks.

Website : [https://www.availproject.org](https://www.availproject.org/)

Twitter : <https://twitter.com/AvailProject>

Discord : <https://discord.gg/availproject>


# Installation

**Chain ID**: Goldberg | **Latest Version Tag**: v18.0.0&#x20;

### Step 1: Set up your Avail Node

***

Here you have to put name of your node name (validator) that will be visible in explorer

```
NODENAME=<YOUR_NODE_NAME_GOES_HERE>
```

Save and import variables into system

```
AVAIL_PORT=30333
echo "export NODENAME=$NODENAME" >> $HOME/.bash_profile
echo "export AVAIL_PORT=${AVAIL_PORT}" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

***

**Update system and install dependencies**

```
sudo apt update && sudo apt upgrade -y
sudo apt install curl tar wget clang pkg-config protobuf-compiler libssl-dev jq build-essential protobuf-compiler bsdmainutils git make ncdu gcc git jq chrony liblz4-tool -y
```

**Install Rust**

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
rustup default stable
rustup update
rustup update nightly
rustup target add wasm32-unknown-unknown --toolchain nightly
```

**Download and build binaries**

```
git clone https://github.com/availproject/avail.git
cd avail
mkdir -p data
git checkout v1.8.0.0
cargo build --release -p data-avail
sudo cp $HOME/avail/target/release/data-avail /usr/local/bin
```

#### Create a service

```
sudo tee /etc/systemd/system/availd.service > /dev/null <<EOF
[Unit]
Description=Avail Validator
After=network-online.target

[Service]
User=$USER
ExecStart=$(which data-avail) -d `pwd`/data --chain goldberg --validator --name $NODENAME
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable availd
sudo systemctl restart availd && sudo journalctl -u availd -f -o cat
```

#### Before you can become an active validator, you need to bond your funds to your node.

{% hint style="info" %}
Stake your validator: <https://docs.availproject.org/operate/validator/staking>
{% endhint %}

### Step 2: Create wallet and Set Identity

{% hint style="info" %}
Refer to this official docs : <https://docs.availproject.org/about/identity/>
{% endhint %}


# Challenge Set Identity

Your points will based on challenge completed.

### Step 1: Run a Full node

{% content-ref url="/pages/KIvCoiFF0oKkfOBUEqR5" %}
[Installation](/testnet-node/avail-network/installation)
{% endcontent-ref %}

### Step 2: Create account & Set Identity

* Create account

Go to <https://goldberg.avail.tools/#/accounts>

<figure><img src="/files/6lof2uf58ARxSriWtwCk" alt=""><figcaption></figcaption></figure>

* Set identity

You need minimum 10 AVAIL tokens for set identification, request faucet on <https://discord.com/channels/1065831819154563132/1171414018028740698>

<figure><img src="/files/dGinmhyEPtIqI0IZj5lW" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/f8zXEwlOVEc31mQ1IVI3" alt=""><figcaption><p>Fill all necessary form. More details = More Token.</p></figcaption></figure>

* Done


# Challenge Add Pool

Your points will based on challenge completed.

### Step 1: Run a Full node

Navigate to [https://goldberg.avail.tools/#/staking](https://goldberg.avail.tools/#/staking/pools)

### Step 2: Add Pool

* Choose Pool from the Staking bar and Press + button on Add pool

<figure><img src="/files/uKg4eqFjN1kZLP7ffFC5" alt=""><figcaption></figcaption></figure>

* Choose your wallet to make pool
* Fill how much you want to bond
* To make pool press Create

<figure><img src="/files/f0lujqJ4IZ4ArbpzNZw3" alt=""><figcaption><p>You need Minimum 10 AVL to make a Pool</p></figcaption></figure>

* Done


# Cortensor

Pioneering Decentralized AI Inference, Democratizing Universal Access.

{% embed url="<https://dashboard-devnet3.cortensor.network/node>" %}

<figure><img src="/files/bGEBHHvN6mNFCfOglR83" alt=""><figcaption></figcaption></figure>

*Cortensor leverages decentralized AI inference to democratize technology and ensure universal access. Our platform excels in delivering the critical last mile of AI services, providing advanced solutions for seamless integration with users and services.*

**Website** : [https://www.cortensor.network](https://www.cortensor.network/)

**Twitter** : <https://x.com/cortensor>

**Discord** : <https://discord.com/invite/cortensor>

**Telegram :** <https://t.me/CortensorNetwork>

**Medium :** [https://cortensor.medium.com](https://cortensor.medium.com/)

**Uniswap** : <https://app.uniswap.org/explore/tokens/ethereum/0x8e0eef788350f40255d86dfe8d91ec0ad3a4547f>


# Staking and Funding

## Staking $COR (2k per Node)

1. Buy $COR on Uniswap (ETH Mainnet) -> [***Link***](https://app.uniswap.org/explore/tokens/ethereum/0x8e0eef788350f40255d86dfe8d91ec0ad3a4547f)&#x20;

<figure><img src="/files/1Nq97PYhc5SBLI3ftCvP" alt="" width="375"><figcaption></figcaption></figure>

2. Stake ***2000 $COR on Pool 3*** to run 1 Node (Maks. 10 Node per user) -> [***Link***](https://stake.cortensor.network/)

<figure><img src="/files/ZV3jI2JfFYIC20YKEb6u" alt="" width="375"><figcaption></figcaption></figure>

3. Request on Cortensor Discord for WL the miner address on [***#testing-ground***](https://discord.com/channels/1261511806350790767/1302949161011773491) channel and provide Staking Address, Miner Address, DC and TG.

<figure><img src="/files/JBckre7Hdiy6wY4wUxAE" alt="" width="375"><figcaption></figcaption></figure>

{% hint style="success" %}
Note : You will get Miner address when you generate during setup on your vps
{% endhint %}

## Getting ETH on ARB Sepolia

1. Firstly you need to bridge ETH Mainnet -> ETH Sepolia. [***here***](https://testnetbridge.com/sepolia)

<figure><img src="/files/pjCPAIsKtFDiqbgQUMv4" alt="" width="256"><figcaption></figcaption></figure>

1. Then, you should bridge ETH Testnet from Sepolia -> ARB Sepolia. [***here***](https://bridge.arbitrum.io/?amount=1\&destinationChain=arbitrum-sepolia\&sourceChain=sepolia)

<figure><img src="/files/BXKU9P1fayAYNgBpVaMQ" alt="" width="228"><figcaption></figcaption></figure>

1. Send your ETH on ARB Sepolia to your Miner Address.

{% hint style="success" %}
Note : \
1\. Use L2 ETH to bridge for cheaper gas fee

2\. You will get Miner address when you generate during setup on your vps
{% endhint %}

## Setup your own RPC

1. Create account and Login, we recomend using drpc.org because they didn’t limit for free user. [***here***](https://drpc.org?ref=ba6cbe)

<figure><img src="/files/HHb3nQ7GaPOPaCe571C0" alt="" width="375"><figcaption></figcaption></figure>

2. To create API Key : Add key -> Rename key -> Create

<figure><img src="/files/0hcGQGRnlpqMaUVRzPTC" alt="" width="375"><figcaption></figcaption></figure>

3. Copy ARB Sepolia endpoint and Save.

<figure><img src="/files/eywx2paAV0BoofisbTWQ" alt="" width="375"><figcaption></figcaption></figure>

4. Found *.**env*** file on ***.cortensor*** folder change ***HOST*** with your own RPC from drpc.

<figure><img src="/files/ZTstBKXaYUD7KVkuf1Ih" alt="" width="375"><figcaption></figcaption></figure>

***


# Installation

The complete instructions on how step by step guide running Cortensor Mining AI.

## Prerequisite

**Update system and install dependencies**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4
sudo apt -qy upgrade
```

**Clone Installation**&#x20;

```
git clone https://github.com/cortensor/installer
cd installer
```

<figure><img src="/files/4g1BdTyCsOx462uzY3Jo" alt="" width="375"><figcaption></figcaption></figure>

**Install Docker (located on installer folder)**

```
#For Ubuntu 22.04
./install-docker-ubuntu.sh


#For Debian 9
./install-docker-debian.sh

```

<figure><img src="/files/ezjYM5YC0MLPjNxoj5Hu" alt="" width="375"><figcaption></figcaption></figure>

**Install IPFS (located on installer folder)**

```
./install-ipfs-linux.sh

```

<figure><img src="/files/pHnB0aUBLGbNYTF6uHma" alt="" width="375"><figcaption></figcaption></figure>

**Install Cortensord (located on installer folder)**

```
./install-linux.sh

#this command will generate new user "deploy"
```

<figure><img src="/files/kVPtCbGlupO6mdbS78X9" alt="" width="375"><figcaption></figcaption></figure>

**Copy installer folder to deploy home**

```
cd ~/
cp -Rf ./installer /home/deploy/installer
chown -R deploy.deploy /home/deploy/installer
```

#### Switch to user "deploy" and Verify the installation

```
sudo su deploy
cd ~/

ls -al /usr/local/bin/cortensord
ls -al $HOME/.cortensor/bin/cortensord
ls -al /etc/systemd/system/cortensor.service
ls -al $HOME/.cortensor/bin/start-cortensor.sh
ls -al $HOME/.cortensor/bin/stop-cortensor.sh
docker version
ipfs version

Note : If the output similiar this and no error found your installation is success
```

<figure><img src="/files/zWoLPaa1MSwOK7unclLZ" alt="" width="375"><figcaption></figcaption></figure>


# Node Management

Your address needs to be whitelisted in for running node by Cortensor Admin (2k $COR per Node)

## Key management (need to login as "deploy" user)

#### Generate Key

```
/usr/local/bin/cortensord ~/.cortensor/.env tool gen_key
```

<figure><img src="/files/c1eplTTehE4wxSiYPP2n" alt=""><figcaption></figcaption></figure>

Register the node (need to be whitelisted)

```
/usr/local/bin/cortensord ~/.cortensor/.env tool register
```

<figure><img src="/files/8tCkbltrsJqnSxSKlCk1" alt=""><figcaption></figcaption></figure>

#### Verify the node

```
/usr/local/bin/cortensord ~/.cortensor/.env tool verify
```

<figure><img src="/files/UpSGMvISRQONuNoMF8nK" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/0jpeonCFrKIYFY8en9HY" alt=""><figcaption><p>Normal logs with no error</p></figcaption></figure>

## Node Management

#### Start Node

```
sudo systemctl start cortensor
#you need to input pass for "deploy" user
```

#### Stop Node&#x20;

```
sudo systemctl stop cortensor
```

#### Restart Node

```
sudo systemctl restart cortensor
```

## Debugging & Troubleshoot (Linux)

#### Check Log

```
tail -f /var/log/cortensord.log
```

#### Check Node Address & ID

```
/usr/local/bin/cortensord ~/.cortensor/.env tool id
```

**Check NodeStats**

```
/usr/local/bin/cortensord ~/.cortensor/.env tool stats
```

#### Kill IPFS Process (Linux & OSX)

```
pkill ipfs
```

***


# Monitoring

## Official Cortensor Official Dashboard

{% embed url="<https://dashboard-devnet3.cortensor.network/nodestats>" %}
Input your miner address to show your Node status
{% endembed %}

<figure><img src="/files/iLZOrebcFm32kiGaU5Fy" alt="" width="563"><figcaption></figcaption></figure>

## Telegram Bot Node&#x20;

{% embed url="<https://t.me/Cortensor_BOT>" %}
Just input your Node address to monitor up to 5 address
{% endembed %}

<figure><img src="/files/G0WakbZ3OOfCDKkHi72f" alt="" width="366"><figcaption></figcaption></figure>


# CrossFi

Stake with LOGOSNODOS

{% embed url="<https://testnet.itrocket.net/crossfi/staking/mxvaloper1rmvcs3mcvvanz5c3nxxdkhywc7tskmu8zpqh7z>" %}

<figure><img src="/files/Ql5mEiU37hS2J7iJSv0g" alt=""><figcaption></figcaption></figure>

CrossFi Chain is a layer 1 blockchain with a modular architecture. It consists of two integral parts, Cosmos and EVM. Each part is responsible for its specific functionality, with their work completely synchronized as a single organism.

**Website** : [https://crossfi.org](https://crossfi.org/)

**Twitter** : <https://x.com/crossfichain>

**Discord** : <https://discord.gg/crossfi>

**Linkedin :** [https://www.linkedin.com/company/crossfichain](https://www.linkedin.com/company/crossfichain/about/)

**Facebook :** <https://m.facebook.com/crossfiofficial>

**Medium :** <https://medium.com/@crossfichain>

**Documentation** : <https://docs.crossfi.org/>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: crossfi-evm-testnet-1 | **Latest Version Tag**: 0.3.0-prebuild3 | **Wasm**: OFF

## Installation

## Install dependencies

**Setting up variable**

```
echo "export CROSSFI_CHAIN_ID=crossfi-evm-testnet-1" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.21.4.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Download and build binaries**

```
cd $HOME
rm -rf crossfi
git clone  crossfi
cd crossfi
git checkout 0.3.0-prebuild3
make install
```

**Change your moniker**&#x20;

```
crossfid init <moniker> --chain-id crossfi-evm-testnet-1
```

**Download Genesis**

```
wget -O $HOME/.mineplex-chain/config/genesis.json https://testnet-files.itrocket.net/crossfi/genesis.json
wget -O $HOME/.mineplex-chain/config/addrbook.json https://testnet-files.itrocket.net/crossfi/addrbook.json
```

#### Set the prunning, prometheus, indexer and gas prices

```
PRUNING="custom"
PRUNING_KEEP_RECENT="100"
PRUNING_INTERVAL="19"

sed -i -e "s/^pruning *=.*/pruning = "$PRUNING"/" $HOME/.mineplex-chain/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = "$PRUNING_KEEP_RECENT"/" $HOME/.mineplex-chain/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = "$PRUNING_INTERVAL"/" $HOME/.mineplex-chain/config/app.toml
sed -i 's|^prometheus *=.*|prometheus = true|' $HOME/.mineplex-chain/config/config.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/crossfid.service > /dev/null <<EOF
[Unit]
Description=crossfi testnet node
After=network-online.target

[Service]
User=$USER
ExecStart=$(which crossfid) start
Restart=always
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable crossfid
```

#### Start service and check the logs

```
sudo systemctl restart crossfid && sudo journalctl -fu crossfid -o cat
```


# Cheat Sheet

## Key management

#### Add new key

```
crossfid keys add wallet
```

#### Recover existing key

```
crossfid keys add wallet --recover
```

#### List all keys

```
crossfid keys list
```

#### Delete key

```
crossfid keys delete wallet
```

#### Export key to the file

```
crossfid keys export wallet
```

#### Import key from the file

```
crossfid keys import wallet wallet.backup
```

#### Query wallet balance

```
crossfid q bank balances $(crossfid keys show wallet -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity**, **details** and **website** to match your values.
{% endhint %}

#### Create new validator

```
crossfid tx staking create-validator \
  --amount 1000000mpx \
  --commission-max-change-rate "0.1" \
  --commission-max-rate "0.2" \
  --commission-rate "0.1" \
  --min-self-delegation "1" \
  --pubkey  $(swisstronikd tendermint show-validator) \
  --moniker "<your moniker>" \
  --website "<your website>" \
  --identity "<your identity> \
  --details "<your descriptions> \
  --chain-id $CROSSFI_CHAIN_ID \
  --gas-prices 10000000000000mpx \
  --from wallet \
  -y
```

#### Edit existing validator

```
crossfid tx staking edit-validator \
  --moniker=<your moniker> \
  --identity=<your_keybase_id> \
  --website=<your_website> \
  --details=<your_validator_description> \
  --chain-id=$CROSSFI_CHAIN_ID \
  --from=wallet \
  -y
```

#### Unjail validator

```
crossfid tx slashing unjail \
  --broadcast-mode=block \
  --chain-id=$CROSSFI_CHAIN_ID \
  --gas=auto \
  --from=wallet \
  -y
```

#### View validator details

```
crossfid q staking validator $(crossfid keys show wallet --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
crossfid tx distribution withdraw-all-rewards --from wallet --chain-id crossfi-evm-testnet-1 --gas-prices 10000000000000mpx  --gas-adjustment 1.5 --gas "auto" -y 
```

#### Withdraw commission and rewards from your validator

```
crossfid tx distribution withdraw-rewards $(crossfid keys show wallet --bech val -a) --commission --from wallet --chain-id crossfi-evm-testnet-1 --gas-prices 10000000000000mpx  --gas-adjustment 1.5 --gas "auto" -y 
```

#### Delegate tokens to yourself

```
crossfid tx staking delegate $(crossfid keys show wallet --bech val -a) 1000000mpx --from wallet --chain-id crossfi-evm-testnet-1 --gas-prices 10000000000000mpx  --gas-adjustment 1.5 --gas "auto" -y 
```

#### Redelegate tokens to another validator

```
crossfid tx staking redelegate $(crossfid keys show wallet --bech val -a) <TO_VALOPER_ADDRESS> 1000000mpx --from wallet --chain-id crossfi-evm-testnet-1 --gas-prices 10000000000000mpx  --gas-adjustment 1.5 --gas "auto" -y 
```

#### Unbond tokens from your validator

```
crossfid tx staking unbond $(crossfid keys show wallet --bech val -a) 1000000mpx --from wallet --chain-id crossfi-evm-testnet-1 --gas-prices 10000000000000mpx  --gas-adjustment 1.5 --gas "auto" -y 
```

#### Send tokens to the wallet

```
crossfid tx bank send wallet <TO_WALLET_ADDRESS> 1000000mpx --from wallet --chain-id crossfi-evm-testnet-1 --gas-prices 10000000000000mpx  --gas-adjustment 1.5 --gas "auto" -y 
```

***

## Governance

#### List all proposals

```
crossfid query gov proposals
```

#### View proposal by id

```
crossfid query gov proposal 1
```

#### Vote 'Yes'

```
crossfid tx gov vote 1 yes --from wallet --chain-id $CROSSFI_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 10000000000000mpx -y
```

#### Vote 'No'

```
crossfid tx gov vote 1 no --from wallet --chain-id $CROSSFI_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 10000000000000mpx -y
```

#### Vote 'Abstain'

```
crossfid tx gov vote 1 abstain --from wallet --chain-id $CROSSFI_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 10000000000000mpx -y
```

#### Vote 'NoWithVeto'

```
crossfid tx gov NoWithVote 1 yes --from wallet --chain-id $CROSSFI_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 10000000000000mpx -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.mineplex-chain/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.mineplex-chain/config/app.toml
```

#### Get sync info

```
crossfid status 2>&1 | jq .SyncInfo
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Enable prometheus

```
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.mineplex-chain/config/config.toml
```

#### Reset chain data

```
crossfid tendermint unsafe-reset-all --keep-addr-book --home $HOME/.mineplex-chain --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
cd $HOME 
sudo systemctl stop crossfid 
sudo systemctl disable crossfid 
sudo rm /etc/systemd/system/crossfid.service 
sudo systemctl daemon-reload 
sudo rm -rf $(which crossfid)
sudo rm -rf $HOME/.mineplex-chain 
sudo rm -rf $(which crossfid) 
```


# Juneo Network

Stake with LOGOSNODOS

{% embed url="<https://mcnscan.io/validator/NodeID-KXZBPqAAQ3RnWuvgsUhkq62KHgbp9wthA>" %}

RPC :&#x20;

```
```

API :&#x20;

```
```

<figure><img src="/files/EKiyQpq3A4Tp5ujT0g8n" alt=""><figcaption></figcaption></figure>

JUNEO is a public, decentralized Proof-of-Stake Network that utilizes the Native token JUNE.

The protocol is based on the innovative and robust Snowmann++ consensus from [Avalanche](https://www.avax.network/).

The architecture has been redesigned with new functionalities added.

* **Cost-efficient solution** accessible to any team in the world&#x20;
* **Dedicated tokenomics** with fee collection to sponsor transactions&#x20;
* **Click and deploy tools** for Super Networks and blockchains&#x20;
* **Cross-Chain transfers** in less than 2 seconds between chains

JUNEO makes it possible to create networks of [**Nodes**](broken://pages/j1yQxyeijctAXsZWrQvd) (called [**Supernets**](broken://pages/T1oXmJV4fhQPszhq5R2f)) that allow the creation of as many **blockchains** as needed.

**Website :** <https://juneo.com/>

**Twitter :** <https://twitter.com/JUNEO_official>

**Discord :** [discord.gg/juneonetwork](https://t.co/3W6OJoAZ51)

**Telegram :** <https://t.me/JuneoOfficial>


# Installation

There are 3 Options to install the Node by Manual, Script and Docker.

### Firstly you need to add user <a href="#run-an-avalanche-node" id="run-an-avalanche-node"></a>

```
adduser xxx
```

using your user

```
sudo su - xxx
```

or

```
su - xxx
```

Install screen for running in background

```
sudo apt install screen
```

### Setup and Connect a node to the Socotra Testnet v1 <a href="#run-an-avalanche-node" id="run-an-avalanche-node"></a>

For this step, you will have to download the binary files found [here](https://github.com/Juneo-io/juneogo-binaries). If you have [git](https://git-scm.com/) installed on your system, please execute the following in your command line:

```
git clone https://github.com/Juneo-io/juneogo-binaries
```

Your binaries will be found in the `juneogo-binaries` folder on your system.

#### Configuring the initial binary files

The first step is to transfer the required binaries to the **home directory** of the server on which you wish to run your node. These binaries are:

1. juneogo
2. jevm
3. srEr2XGGtowDVNQ6YgXcdUb16FGknssLTGUFYg7iMqESJ4h8e

After moving these binaries to the server, we next step is to allow execution permissions for them with the following commands:

```
chmod +x juneogo
chmod +x jevm
chmod +x srEr2XGGtowDVNQ6YgXcdUb16FGknssLTGUFYg7iMqESJ4h8e
```

Next, the directory `.juneogo/plugins` should be created in the home directory of our server,  and the *jevm* binary should be placed there:

```
mkdir -p .juneogo/plugins
mv jevm .juneogo/plugins
mv srEr2XGGtowDVNQ6YgXcdUb16FGknssLTGUFYg7iMqESJ4h8e .juneogo/plugins
```

The structure of your home directory should resemble the following:

```
├── juneogo
├── .juneogo/
│   ├── plugins/
│   │   └── jevm
│   │   └── srEr2XGGtowDVNQ6YgXcdUb16FGknssLTGUFYg7iMqESJ4h8e
```

{% hint style="info" %}
If these files are structured differenty than above, you will not be able to connect your node.
{% endhint %}

You may now connect the node to the Socotra network by executing the juneogo binary with the following command:

```
screen -S juneo
```

```
./juneogo
```

{% hint style="warning" %}
Press Ctrl + A + D ( to detach and make screen keep running)\
Please make sure this process keeps running in the background. If the execution of the juneogo executable stops, your node will be inactive.
{% endhint %}

You may check if the node has boostrapped with the following call:

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

Example response:

```
{
  "jsonrpc": "2.0",
  "result": {
    "isBootstrapped": true
  },
  "id": 1
}
```


# Create Supernet

Please download the [juneojs-examples](https://github.com/Juneo-io/juneojs-examples) repository on your local machine. If you have [git](https://git-scm.com/) installed on your system, please execute the following in your command line:

```
git clone https://github.com/Juneo-io/juneojs-examples
```

The required files will be found in the directory `juneojs-examples`.

Next, please open `juneojs-examples` in a command line and execute the following command:

```
npm install
```

After this, open `juneojs-examples` in a code editor of your choice, create a .env file from the provided .env.example, and paste your mnemonic phrase in the MNEMONIC variable. Example:

```
MNEMONIC="raven whip pave toy benefit moment twin acid wasp satisfy crash april"
```

To perform the transactions required to deploy a Supernet, you will need to have funds on the P-chain.  In this tutorial, we will first be crossing assets from the JUNE-chain to the JVM-chain, and then from  the JVM-chain to the P-chain.

In a command line window open in the root of the JuneoJS library, execute the following:

```
npx ts-node ./src/docs/crossJUNEtoJVM.ts
```

This will cross 1.1 JUNE from the JUNE-chain to the JVM-chain. After this, we will cross 1 JUNE from the JVM-chain to the P-chain by executing the following command:

```
npx ts-node ./src/docs/crossJVMtoP.ts
```

The next step is the Supernet creation. Please execute the following in the comand line:

```
npx ts-node ./src/supernet/createSupernet.ts
```

This will produce an output to the terminal containing your supernetID. Example: *ZxTjijy4iNthRzuFFzMH5RS2BgJemYxwgZbzqzEhZJWqSnwh.*

This is the id of the transaction that has created your Supernet, and is the id of the Supernet as well. Please save it as we will needed in the following steps.

### Add a validator to the Supernet

The next step is to perform the addSupernetValidator transaction.

{% hint style="info" %}
If your Supernet has no validators, all blockchains in that Supernet will be inactive and will not be able to process transactions.
{% endhint %}

Please open the file `./src/supernet/addSupernetValidator.ts` in your code editor, and update the following variables to contain the correct values. Example:

```
const nodeId: string = 'NodeID-B2GHMQ8GF6FyrvmPUX6miaGeuVLH9UwHr'
const supernetId: string = 'ZxTjijy4iNthRzuFFzMH5RS2BgJemYxwgZbzqzEhZJWqSnwhP'
const durationInDays: number = 4 // number of days you will validate your Supernet
```

We will keep the **durationInDays** variable the same. However, you may update it to a diffent value.

{% hint style="info" %}
The variable **durationInDays** must be less than the amount of remaining days your node will be validating the Primary network.<br>

If your node has 5 days (or a little over 4 days) left of Primary Network validation, you must set **durationInDays** to 4 or less.
{% endhint %}

Then, execute this file:

```
npx ts-node ./src/supernet/addSupernetValidator.ts
```

This will add our node as a validator for our supernet. However, we need to perform an additional step before our node can begin validating our Supernet. First, please stop your node.

For users following the [manual ](broken://pages/8wCmuDprLmpqHNt5EwnG)guide for setting up juneogo: please create a file titled `config.json` in the home directory.&#x20;

For users following the [install script](broken://pages/CCnlAB301M6pyPPdy4p4) guide for setting up juneogo: your `config.json` can already be found in the home directory.&#x20;

For users who are running juneogo using [juneogo-docker](https://github.com/Juneo-io/juneogo-docker): your config file can be found in the `juneogo-docker/juneogo/.juneogo/config.json` directory.

In your `config.json` file, please include the configuration flag `track-supernets,` specifying the Supernets you want your node to track (in this case, the Supernet you have just created).

Example:

```
{
 "track-supernets":"ZxTjijy4iNthRzuFFzMH5RS2BgJemYxwgZbzqzEhZJWqSnwhP"
}
```

After saving the file, you may run your node again.&#x20;

For users following the [manual ](broken://pages/8wCmuDprLmpqHNt5EwnG)juneogo setup guide, please execute the following :

```
./juneogo --config-file="./config.json"
```

For users following the [install script](broken://pages/CCnlAB301M6pyPPdy4p4) juneogo setup guide, please restart the juneogo service:

```
systemctl --user restart juneogo.service
```

For users running juneogo using [juneogo-docker](https://github.com/Juneo-io/juneogo-docker), please re-start your node using docker compose.

Your node is now tracking the Supernet you have just created.&#x20;

{% hint style="info" %}
If **your node** is the only node validating your Supernet - once your node stops validating it, all chains within it will not be able to process transactions.\
\
You would have to re-perform the **Add Supernet Validator** transaction for your Supernet's chains to process transactions again.
{% endhint %}

You may now proceed to the next step: [Deploy a VM](broken://pages/aVPFJQZplrtkf4b1LLeA).


# Deploy a VM

After you have [created your Supernet](/testnet-node/juneo-network/create-supernet), you can deploy a VM on it.

{% hint style="info" %}
The pre-requisite for this tutorial is that you have already [added a JUNEO validator node](broken://pages/oon5vLV2OlCX4ZXpO94b), [created a Supernet](broken://pages/Ff3vIF8W7yGsgA1fqcin) and [added a Supernet validator](broken://pages/Ff3vIF8W7yGsgA1fqcin#add-supernet-validator).
{% endhint %}

We will be using the example files found in the repository [juneogo-examples](https://github.com/Juneo-io/juneojs-examples) to deploy an supernetevm on our existing Supernet.

{% hint style="info" %}
Please make sure that you have [Node.JS](https://nodejs.org/en) installed on your system, along with the npm package[ ts-node](https://www.npmjs.com/package/ts-node) (which will be used to execute the sample code provided in JuneoJS).
{% endhint %}

### Deploying a VM

Assuming you have followed the [steps for creating a supernet](broken://pages/Ff3vIF8W7yGsgA1fqcin), you should have the [juneojs-examples](https://github.com/Juneo-io/juneojs-examples) folder available. Open [juneojs-examples](https://github.com/Juneo-io/juneojs-examples) directory in a code editor of your choice, create a .env file from the provided .env.example, and paste your mnemonic phrase in the MNEMONIC variable. Example:

```
MNEMONIC="raven whip pave toy benefit moment twin acid wasp satisfy crash april"
```

Next, open the file `./src/supernet/createChain.ts`. Please find and update the following variables to contain the correct values. Example:

```
const supernetId: string = 'ZxTjijy4iNthRzuFFzMH5RS2BgJemYxwgZbzqzEhZJWqSnwhP' // your supernet id

const chainName: string = 'Chain A'

const chainId: number = 330333

const genesisMintAddress: string = '0x44542FD7C3F096aE54Cc07833b1C0Dcf68B7790C' // your wallet address here
```

{% hint style="danger" %}
Never use the same **chainId** value more than once- this can cause unexpected errors for your Supernet chains in the future.
{% endhint %}

{% hint style="info" %}
Please make sure to specify the `chainId` variable to a value that is not already taken by another chain.

For **Socotra v1**, please use a random number from 300,000 - 399,999.\
For **Socotra v2**, please use a random number from 200,000 - 299,999.

For **Mainnet,** please use a number starting from 450,000.
{% endhint %}

{% hint style="info" %}
Avoid assigning the`chainId` variable a number with repetative digits (such as 334455, 333444, 333333, 343434 or similar).
{% endhint %}

After this, execute this file in the command line using ts-node:

```
npx ts-node ./src/supernet/createChain.ts
```

Your command line output should resemble the following, indicating that your VM was successfully deployed:

```
Created chain with id: 2LxhUB7z7yxvBkHiiwp8MrALgy7rka3y6MriL2JAeX858wUK5D
```

### Indexation of your chain on the explorer

For your chain to be eligible for indexation on the explorer, you will need to disable pruning for your newly created chain, allowing archive node functionality. This is done by creating a `config.json` file on your JUNEO validator node in the location `.juneogo/configs/chains/chainId.`

For a chain which has the id of `2LxhUB7z7yxvBkHiiwp8MrALgy7rka3y6MriL2JAeX858wUK5D`, you would execute the following commands from the home directory:

```
cd .juneogo

mkdir configs
cd configs

mkdir chains
cd chains

mkdir 2LxhUB7z7yxvBkHiiwp8MrALgy7rka3y6MriL2JAeX858wUK5D
cd 2LxhUB7z7yxvBkHiiwp8MrALgy7rka3y6MriL2JAeX858wUK5D

nano config.json
```

Next, paste the following inside the `config.json` file:

```
{
"pruning-enabled": false,
  "eth-apis": ["public-eth", "public-eth-filter","net","web3","internal-public-eth","internal-public-blockchain","internal-public-transaction-pool","internal-public-debug","debug-tracer"]
}
```

In addition to this, it is required that your node accepts API calls from remote machines. For this, we have to make updates to the `config.json` file our node is using.

This file should include the `http-host` config flag, and it's value should be set to your public IP address. Example:

```
"http-host":"XXX:XXX:XXX:XXX"
```

{% hint style="info" %}
If you are using [juneogo-docker](https://github.com/Juneo-io/juneogo-docker) to run your node, the **`http-host`** flag should remain unchanged.
{% endhint %}

Following the previous steps from the documentation, this `config.json` file should include the following lines:

```
{
 "track-supernets":"ZxTjijy4iNthRzuFFzMH5RS2BgJemYxwgZbzqzEhZJWqSnwhP",
 "http-host":"XXX.XXX.XXX.XXX"
}
```

After updating this file, please re-start your node.&#x20;

The next step is to submit your Supernet and Blockchain data to us for indexation.

{% hint style="info" %}
Before proceeding with the next step, please perform a few transactions on your chain using MetaMask, such as sending some tokens to any address.
{% endhint %}

Please submit your Supernet and Blockchain information to us in the following format:

```
Supernet
- Name
- Description
- id

Blockchain
- Name 
- Description 
- Currency (in ALL-CAPS format)
- Decimals 
- Host (http://xxx.xxx.xxx.xxx:9650 or with domain name) 
- rpc (http://xxx.xxx.xxx.xxx:9650/ext/bc/id/rpc)
- Logo (min 273x273 or greater.
        In .png format. 
        The width:height ratio should be 1:1)
- id
```

{% hint style="info" %}
Please use unique descriptive names for your Supernet and Blockchain. Avoid names such as "Test Supernet" or "Test Blockchain".
{% endhint %}


# Namada

Stake with LOGOSNODOS

RPC :&#x20;

```
```

API :&#x20;

```
```

<figure><img src="/files/h0A3tSHRBLJkm5LqLgNK" alt=""><figcaption></figcaption></figure>

Namada is an IBC-based, PoS Layer 1 blockchain redefining privacy in a multi-asset, interchain era. Also Ethereum-compatible.

Website : <https://namada.net/>

Twitter : <https://twitter.com/namada>

Discord : <https://discord.com/invite/namada>

**Telegram :** <https://t.me/namadaprotocol>

**Documentation :** <https://namada.net/community/docs>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: public-testnet-15.0dacadb8d663 | **Latest Version Tag**: v0.37.2 | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Install Rust**

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source $HOME/.cargo/env
```

**Set Variable**

```
NAMADA_PORT=15
echo "export NAMADA_PORT="$NAMADA_PORT"" >> $HOME/.bash_profile
echo "export ALIAS="CHOOSE_A_NAME_FOR_YOUR_VALIDATOR"" >> $HOME/.bash_profile
echo "export WALLET="CHOOSE_A_WALLET_NAME"" >> $HOME/.bash_profile
echo "export PUBLIC_IP=$(wget -qO- eth0.me)" >> $HOME/.bash_profile
echo "export TM_HASH="v0.1.4-abciplus"" >> $HOME/.bash_profile
echo "export CHAIN_ID="public-testnet-15.0dacadb8d663"" >> $HOME/.bash_profile
echo "export BASE_DIR="$HOME/.local/share/namada"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Protocol Buffers**

```
cd $HOME
curl -L -o protobuf.zip https://github.com/protocolbuffers/protobuf/releases/download/v24.4/protoc-24.4-linux-x86_64.zip
mkdir protobuf_temp && unzip protobuf.zip -d protobuf_temp/
sudo cp protobuf_temp/bin/protoc /usr/local/bin/
sudo cp -r protobuf_temp/include/* /usr/local/include/
rm -rf protobuf_temp protobuf.zip
```

**Install CometBFT**

```
cd $HOME
rm -rf cometbft
git clone https://github.com/cometbft/cometbft.git
cd cometbft
git checkout v0.37.2
make build
sudo cp $HOME/cometbft/build/cometbft /usr/local/bin/
cometbft version
```

**Download and build binaries**

```
cd $HOME
rm -rf $HOME/namada
git clone https://github.com/anoma/namada
cd $HOME/namada
wget https://github.com/anoma/namada/releases/download/v0.28.1/namada-v0.28.1-Linux-x86_64.tar.gz
tar -xvf namada-v0.28.1-Linux-x86_64.tar.gz
rm namada-v0.28.1-Linux-x86_64.tar.gz
cd namada-v0.28.1-Linux-x86_64
sudo mv namada namadan namadac namadaw /usr/local/bin/
if [ ! -d "$HOME/.local/share/namada" ]; then
    mkdir -p "$HOME/.local/share/namada"
fi
namada --version
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${NAMADA_PORT}658%g;
s%:26657%:${NAMADA_PORT}657%g;
s%:26656%:${NAMADA_PORT}656%g;
s%:26545%:${NAMADA_PORT}545%g;
s%:8545%:${NAMADA_PORT}545%g;
s%:26660%:${NAMADA_PORT}660%g" $HOME/.local/share/namada/public-testnet-15.0dacadb8d663/config.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/namadad.service > /dev/null <<EOF
[Unit]
Description=namada
After=network-online.target

[Service]
User=$USER
WorkingDirectory=$BASE_DIR
Environment=CMT_LOG_LEVEL=p2p:none,pex:error
Environment=NAMADA_CMT_STDOUT=true
Environment=NAMADA_LOG=info
ExecStart=$(which namada) node ledger run
StandardOutput=syslog
StandardError=syslog
Restart=always
RestartSec=10
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable namadad
sudo systemctl restart namadad && sudo journalctl -u namadad -f
```


# Cheat Sheet

## Key management

#### Add new key

```
KEY_ALIAS="keysha"; namada wallet key gen --alias $KEY_ALIAS
```

#### Recover existing key

```
namada wallet key restore --alias $KEY_ALIAS --hd-path default
```

#### List all keys

```
namada wallet key list
```

#### Query wallet balance

```
namada client balance --owner $KEY_ALIAS
```

#### Add some token using faucet

```
https://faucet.heliax.click/
```

***

## Multisign

#### Generate key-1

```
namadaw key gen --alias my-key1
```

#### Generate key-2

```
namadaw key gen --alias my-key2
```

#### Generate implicit address

```
namadaw address gen --alias my-address
```

**init non-multisig account (single signer)**

```
namadac init-account --alias my-multisig-alias --public-keys my-key1 --signing-keys my-key1
```

**init multisig account (at least 2 signers)**

```
namadac init-account --alias my-multisig-alias --public-keys my-key1,my-key2 --signing-keys my-key1,my-key2 --threshold 2
```

**Submitting a multisignature transaction**

```
mkdir tx_dumps
```

#### Create transaction

```
namadac transfer --source my-multisig-alias --target some-established-account-alias --token NAM --amount 100 --signing-keys my-key1 --dump-tx --output-folder-path tx_dumps
```

#### Signing transaction

```
namadac transfer --source my-multisig-alias --target some-established-account-alias --token NAM --amount 100 --signing-keys my-key1 --dump-tx --output-folder-path tx_dumps
```

#### Save as a variable offline\_signature

```
export SIGNATURE_ONE="offline_signature_FB7246E3FC43F59D8AEEC234EBFDB9DF1AC9BB7B14E536D05A7E2617CA41D4CD_0.tx"
```

**Submit Transaction**

```
namadac tx --tx-path "tx_dumps/a45ef98a817290d6fc0efbd480bf66647ea8061aee1628ce09b4af4f4eeed1c2.tx" --signatures $SIGNATURE_ONE --signatures $SIGNATURE_TWO --owner my-multisig-alias --gas-payer my-key1
```

**Change the multisig threshold**

```
namadac update-account --address my-multisig-address --threshold 1 --signing-keys my-key1,my-key2
```

**Check the threshold has been updated**

```
namadac query-account --owner my-multisig-address
```

**Change the public keys of a multisig account**

```
namadac query-account --owner my-multisig-address
```

**Initialize an established account**

```
namada client init-account --alias establishment --public-keys keysha  --signing-keys keysha  --threshold 1
```

***

## MASP

#### Randomly generate a new spending key

```
namadaw masp gen-key --alias <your-spending-key-alias>
```

#### Create a new payment address

```
namadaw masp gen-addr  --key <your-spending-key-alias> --alias <your-payment-address-alias>
```

#### Send your shielding transfer

```
namadac transfer --source <your-established-account-alias>  --target <your-payment-address-alias>  --token btc --amount <amount-to-shield>
```

#### View balance

```
namadac balance --owner <your-spending-key-alias>
```

#### Shielded transfer (once the user has a shielded balance, it can be transferred to another shielded address)

```
namadac transfer  --source <your-spending-key-alias> --target <destination-payment-address>  --token btc --amount <amount-to-transfer> --signing-keys <your-implicit-account-alias>
```

**Unshielding transfers (it is also possible to transfer the balance to a transparent account)**

```
namadac transfer --source <your-spending-key-alias> --target <some-transparent-address-alias> --token btc  --amount <amount-to-unshield> --signing-keys <your-implicit-account-alias>
```

***

## Validator Operations

#### Check sync status and node info

```
curl http://127.0.0.1:26657/status | jq
```

#### Stake funds

```
namada client bond --validator $ALIAS  --amount 1500 --gas-limit 10000000
```

#### Check your validator bond status

```
namada client bonds --owner $ALIAS
```

#### Check all bonded nodes

```
namada client bonded-stake
```

#### Find all the slashes

```
namada client slashes
```

#### Self Unbonding

```
namada client unbond --validator $ALIAS --amount 0.3
```

#### Non-self unbonding

```
namada client unbond --source aliace --validator $ALIAS --amount 1.2
```

**Withdrawing unbonded tokens**

```
namada client withdraw --source aliace --validator $ALIAS
```

***

## Sync and Consensus

#### Check logs

```
sudo journalctl -u namadad -f
```

#### Check sync status and node info

```
curl http://127.0.0.1:26657/status | jq
```

**Check consensus state**

```
curl -s localhost:26657/consensus_state | jq .result.round_state.height_vote_set[0].prevotes_bit_array
```

**Full consensus state**

```
curl -s localhost:12657/dump_consensus_state
```

#### Your validator votes (prevote)

```
curl -s http://localhost:26657/dump_consensus_state | jq '.result.round_state.votes[0].prevotes' | grep $(curl -s http://localhost:26657/status | jq -r '.result.validator_info.address[:12]')
```

***

## 🚨 Maintenance

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop namadad
sudo systemctl disable namadad
sudo rm -rf /etc/systemd/system/namadad.service
sudo systemctl daemon-reload
sudo rm $(which namada)
sudo rm -rf $HOME/.local/share/namada/public-testnet-15.0dacadb8d663
```


# Pryzm

Stake with LOGOSNODOS

{% embed url="<https://testnet.itrocket.net/pryzm/staking/pryzmvaloper1kzlg7a7pkqes50wpt2tq99xwx6h8wa94fjsyew>" %}

RPC :&#x20;

```
rpc.pryzm.arweave.tech
```

API :&#x20;

```
api.pryzm.arweave.tech
```

<figure><img src="/files/E8FVwvBTKM0NXewPhWQH" alt=""><figcaption></figcaption></figure>

Pryzm is the first layer-1 blockchain dedicated to the harvesting, trading and utilisation of yield.

Website : <https://pryzm.zone/>

Twitter : <https://twitter.com/Pryzm_Zone>

Discord : <https://discord.gg/KzeQBbc8Eg>

**Telegram :** <https://t.me/pryzm_zone>

**Documentation :** <https://docs.pryzm.zone/>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: indigo-1 | **Latest Version Tag**: v0.9.0 | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export WALLET="YOUR WALLET"" >> $HOME/.bash_profile
echo "export MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export PRYZM_CHAIN_ID="indigo-1"" >> $HOME/.bash_profile
echo "export PRYZM_PORT="26"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
cd $HOME
wget https://storage.googleapis.com/pryzm-resources/pryzmd-0.9.0-linux-amd64.tar.gz
tar -xzvf pryzmd-0.9.0-linux-amd64.tar.gz
mv pryzmd $HOME/go/bin
```

Set config and init app

```
pryzmd config node tcp://localhost:${PRYZM_PORT}657
pryzmd config keyring-backend os
pryzmd config chain-id indigo-1
pryzmd init "YOUR NODE NAME" --chain-id indigo-1
```

#### Set custom ports in app.toml

```
sed -i.bak -e "s%:1317%:${PRYZM_PORT}317%g;
s%:8080%:${PRYZM_PORT}080%g;
s%:9090%:${PRYZM_PORT}090%g;
s%:9091%:${PRYZM_PORT}091%g;
s%:8545%:${PRYZM_PORT}545%g;
s%:8546%:${PRYZM_PORT}546%g;
s%:6065%:${PRYZM_PORT}065%g" $HOME/.pryzm/config/app.toml
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${PRYZM_PORT}658%g;
s%:26657%:${PRYZM_PORT}657%g;
s%:6060%:${PRYZM_PORT}060%g;
s%:26656%:${PRYZM_PORT}656%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${PRYZM_PORT}656\"%;
s%:26660%:${PRYZM_PORT}660%g" $HOME/.pryzm/config/config.toml
```

#### Config pruning

```
sed -i -e "s/^pruning *=.*/pruning = \"nothing\"/" $HOME/.pryzm/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.pryzm/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"50\"/" $HOME/.pryzm/config/app.toml
```

#### Set minimum gas price, enable prometheus and disable indexing

```
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0.015upryzm"|g' $HOME/.pryzm/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.pryzm/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.pryzm/config/config.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/pryzmd.service > /dev/null <<EOF
[Unit]
Description=Pryzm node
After=network-online.target
[Service]
User=$USER
WorkingDirectory=$HOME/.pryzm
ExecStart=$(which pryzmd) start --home $HOME/.pryzm
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable pryzmd
sudo systemctl restart pryzmd && sudo journalctl -u pryzmd -f
```


# Cheat Sheet

## Key management

#### Add new key

```
pryzmd keys add $WALLET
```

#### Recover existing key

```
pryzmd keys add $WALLET --recover
```

#### List all keys

```
pryzmd keys list
```

#### Delete key

```
pryzmd keys delete $WALLET
```

#### Export key to the file

```
pryzmd keys export $WALLET
```

#### Import key from the file

```
pryzmd keys import $WALLET wallet.backup
```

#### Query wallet balance

```
pryzmd q bank balances $(quicksilverd keys show $WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
quicksilverd tx staking create-validator \
--amount 1000000upryzm \
--from $WALLET \
--commission-rate 0.1 \
--commission-max-rate 0.2 \
--commission-max-change-rate 0.01 \
--min-self-delegation 1 \
--pubkey $(pryzmd tendermint show-validator) \
--moniker "YOUR MONIKER" \
--identity "YOUR KEYBASE ID" \
--details "YOUR DETAILS" \
--chain-id indigo-1 \
--fees 100upryzm \
-y
```

#### Edit existing validator

```
quicksilverd tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "YOUR MONIKER" \
--identity "YOUR KEYBASE ID" \
--details "YOUR DETAILS" \
--from $WALLET \
--chain-id indigo-1 \
--fees 100upryzm \
-y
```

#### Unjail validator

```
pryzmd tx slashing unjail --from $WALLET --chain-id indigo-1 --fees 100upryzm -y
```

#### Jail reason

```
pryzmd q slashing signing-info $(pryzmd tendermint show-validator)
```

#### List all active validators

```
pryzmd q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
pryzmd q staking validator $(pryzmd keys show $WALLET --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
pryzmd tx distribution withdraw-all-rewards --from $WALLET --chain-id indigo-1 --fees 100upryzm
```

#### Withdraw commission and rewards from your validator

```
pryzmd tx distribution withdraw-rewards $VALOPER_ADDRESS --from $WALLET --commission --chain-id indigo-1 --fees 100upryzm -y
```

#### Delegate tokens to yourself

```
pryzmd tx staking delegate $(pryzmd keys show $WALLET --bech val -a) 1000000upryzm --from $WALLET --chain-id rhye-1 --fees 100upryzm -y
```

#### Delegate tokens to validator

```
pryzmd tx staking delegate YOUR VALOPER ADDRESS 1000000upryzm --from $WALLET --chain-id indigo-1 --fees 100upryzm -y
```

#### Redelegate tokens to another validator

```
pryzmd tx staking redelegate $VALOPER_ADDRESS YOUR VALOPER ADDRESS 1000000upryzm --from $WALLET --chain-id indigo-1 --fees 100upryzm -y
```

#### Unbond tokens from your validator

```
pryzmd tx staking unbond $(pryzmd keys show $WALLET --bech val -a) 1000000upryzm --from $WALLET --chain-id indigo-1 --fees 100upryzm -y
```

#### Send tokens to the wallet

```
pryzmd tx bank send $WALLET_ADDRESS YOUR WALLET ADDRESS 1000000upryzm --fees 100upryzm -y
```

***

## Governance

#### List all proposals

```
pryzmd query gov proposals
```

#### View proposal by id

```
pryzmd query gov proposal 1
```

#### Vote 'Yes'

```
pryzmd tx gov vote 1 yes --from $WALLET --chain-id indigo-1  --fees 100upryzm -y
```

#### Vote 'No'

```
pryzmd tx gov vote 1 no --from $WALLET --chain-id indigo-1  --fees 100upryzm -y
```

#### Vote 'Abstain'

```
pryzmd tx gov vote 1 abstain --from $WALLET --chain-id indigo-1  --fees 100upryzm -y
```

#### Vote 'NoWithVeto'

```
pryzmd tx gov vote 1 no_with_veto --from $WALLET --chain-id indigo-1 --fees 100upryzm -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.pryzm/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.pryzm/config/app.toml
```

#### Update Indexer

**Disable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "null"|' $HOME/.pryzm/config/config.toml
```

**Enable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "kv"|' $HOME/.pryzm/config/config.toml
```

#### Update pruning

```
sed -i \
  -e 's|^pruning *=.*|pruning = "custom"|' \
  -e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
  -e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
  -e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
  $HOME/.pryzm/config/app.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
pryzmd status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
pryzmd status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(pryzmd tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.pryzm/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(pryzmd q staking validator $(pryzmd keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
pryzmd tendermint unsafe-reset-all --keep-addr-book --home $HOME/.pryzm --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop pryzmd
sudo systemctl disable pryzmd
sudo rm -rf /etc/systemd/system/pryzmd.service
sudo rm $(which pryzmd)
sudo rm -rf $HOME/.pryzmd
sed -i "/PRYZM_/d" $HOME/.bash_profile
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable pryzmd
```

#### Disable service

```
sudo systemctl disable pryzmd
```

#### Start service

```
sudo systemctl start pryzmd
```

#### Stop service

```
sudo systemctl stop pryzmd
```

#### Restart service

```
sudo systemctl restart pryzmd
```

#### Check service status

```
sudo systemctl status pryzmd
```

#### Check service logs

```
sudo journalctl -u pryzmd -f --no-hostname -o cat
```


# Quicksilver Protocol

Stake with LOGOSNODOS

{% embed url="<https://testnet.itrocket.net/quicksilver/staking/quickvaloper1pepps2g2agmn39kgydxtqxld2r2n83fgull5vg>" %}

RPC :&#x20;

```
rpc.qck.arweave.tech
```

API :&#x20;

```
api.qck.arweave.tech
```

<figure><img src="/files/2h0il0iEtZZ2LBFnqB8t" alt=""><figcaption></figcaption></figure>

QUICKSILVER : THE COSMOS LIQUID STAKING ZONE.

Website : <https://quicksilver.zone/>

Twitter : <https://twitter.com/quicksilverzone>

Discord : <https://discord.com/invite/xrSmYMDVrQ>

**Telegram :** <https://t.me/quicksilverzone>

**Medium :** <https://medium.com/quicksilverzone>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: rhye-1 | **Latest Version Tag**: v1.4.4-rc.3 | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export WALLET="YOUR WALLET"" >> $HOME/.bash_profile
echo "export MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export QUICKSILVER_CHAIN_ID="rhye-1"" >> $HOME/.bash_profile
echo "export QUICKSILVER_PORT="15"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
cd $HOME
rm -rf ~/quicksilver
git clone https://github.com/ingenuity-build/quicksilver
cd quicksilver
git fetch
git checkout v1.4.4-rc.3
make install
```

Set config and init app

```
quicksilverd config node tcp://localhost:${QUICKSILVER_PORT}657
quicksilverd config keyring-backend os
quicksilverd config chain-id rhye-1
quicksilverd init "YOUR NODE NAME" --chain-id rhye-1
```

#### Set custom ports in app.toml

```
sed -i.bak -e "s%:1317%:${QUICKSILVER_PORT}317%g;
s%:8080%:${QUICKSILVER_PORT}080%g;
s%:9090%:${QUICKSILVER_PORT}090%g;
s%:9091%:${QUICKSILVER_PORT}091%g;
s%:8545%:${QUICKSILVER_PORT}545%g;
s%:8546%:${QUICKSILVER_PORT}546%g;
s%:6065%:${QUICKSILVER_PORT}065%g" $HOME/.quicksilverd/config/app.toml
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${QUICKSILVER_PORT}658%g;
s%:26657%:${QUICKSILVER_PORT}657%g;
s%:6060%:${QUICKSILVER_PORT}060%g;
s%:26656%:${QUICKSILVER_PORT}656%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${QUICKSILVER_PORT}656\"%;
s%:26660%:${QUICKSILVER_PORT}660%g" $HOME/.quicksilverd/config/config.toml
```

#### Config pruning

```
sed -i -e "s/^pruning *=.*/pruning = \"nothing\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"50\"/" $HOME/.quicksilverd/config/app.toml
```

#### Set minimum gas price, enable prometheus and disable indexing

```
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0.0uqck"|g' $HOME/.quicksilverd/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.quicksilverd/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.quicksilverd/config/config.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/quicksilverd.service > /dev/null <<EOF
[Unit]
Description=Quicksilver node
After=network-online.target
[Service]
User=$USER
WorkingDirectory=$HOME/.quicksilverd
ExecStart=$(which quicksilverd) start --home $HOME/.quicksilverd
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

#### Snapshot

```
sudo systemctl stop quicksilverd

cp $HOME/.quicksilverd/data/priv_validator_state.json $HOME/.quicksilverd/priv_validator_state.json.backup

rm -rf $HOME/.quicksilverd/data 
curl https://snapshot.qck.arweave.tech/qck/qck-snapshot-20231218.tar.lz4 | lz4 -dc - | tar -xf - -C $HOME/.quicksilverd

mv $HOME/.quicksilverd/priv_validator_state.json.backup $HOME/.quicksilverd/data/priv_validator_state.json

sudo systemctl restart quicksilverd && sudo journalctl -u quicksilverd -f
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable quicksilverd
sudo systemctl restart quicksilverd && sudo journalctl -u quicksilverd -f
```


# Cheat Sheet

## Key management

#### Add new key

```
quicksilverd keys add $WALLET
```

#### Recover existing key

```
quicksilverd keys add $WALLET --recover
```

#### List all keys

```
quicksilverd keys list
```

#### Delete key

```
quicksilverd keys delete $WALLET
```

#### Export key to the file

```
quicksilverd keys export $WALLET
```

#### Import key from the file

```
quicksilverd keys import $WALLET wallet.backup
```

#### Query wallet balance

```
quicksilverd q bank balances $(quicksilverd keys show $WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
quicksilverd tx staking create-validator \
--amount 1000000uqck \
--from $WALLET \
--commission-rate 0.1 \
--commission-max-rate 0.2 \
--commission-max-change-rate 0.01 \
--min-self-delegation 1 \
--pubkey $(quicksilverd tendermint show-validator) \
--moniker "YOUR MONIKER" \
--identity "YOUR KEYBASE ID" \
--details "YOUR DETAILS" \
--chain-id rhye-1 \
--fees 100uqck \
-y
```

#### Edit existing validator

```
quicksilverd tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "YOUR MONIKER" \
--identity "YOUR KEYBASE ID" \
--details "YOUR DETAILS" \
--from $WALLET \
--chain-id rhye-1 \
--fees 100uqck \
-y
```

#### Unjail validator

```
quicksilverd tx slashing unjail --from $WALLET --chain-id rhye-1 --fees 100uqck -y
```

#### Jail reason

```
quicksilverd q slashing signing-info $(quicksilverd tendermint show-validator)
```

#### List all active validators

```
quicksilverd q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
quicksilverd q staking validator $(quicksilverd keys show $WALLET --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
quicksilverd tx distribution withdraw-all-rewards --from $WALLET --chain-id rhye-1 --fees 100uqck
```

#### Withdraw commission and rewards from your validator

```
quicksilverd tx distribution withdraw-rewards $VALOPER_ADDRESS --from $WALLET --commission --chain-id rhye-1 --fees 100uqck -y
```

#### Delegate tokens to yourself

```
quicksilverd tx staking delegate $(quicksilverd keys show $WALLET --bech val -a) 1000000uqck --from $WALLET --chain-id rhye-1 --fees 100uqck -y
```

#### Delegate tokens to validator

```
quicksilverd tx staking delegate YOUR VALOPER ADDRESS 1000000uqck --from $WALLET --chain-id rhye-1 --fees 100uqck -y
```

#### Redelegate tokens to another validator

```
quicksilverd tx staking redelegate $VALOPER_ADDRESS YOUR VALOPER ADDRESS 1000000uqck --from $WALLET --chain-id rhye-1 --fees 100uqck -y
```

#### Unbond tokens from your validator

```
quicksilverd tx staking unbond $(quicksilverd keys show $WALLET --bech val -a) 1000000uqck --from $WALLET --chain-id rhye-1 --fees 100uqck -y
```

#### Send tokens to the wallet

```
quicksilverd tx bank send $WALLET_ADDRESS YOUR WALLET ADDRESS 1000000uqck --fees 100uqck -y
```

***

## Governance

#### List all proposals

```
quicksilverd query gov proposals
```

#### View proposal by id

```
quicksilverd query gov proposal 1
```

#### Vote 'Yes'

```
quicksilverd tx gov vote 1 yes --from $WALLET --chain-id rhye-1  --fees 100uqck -y
```

#### Vote 'No'

```
quicksilverd tx gov vote 1 no --from $WALLET --chain-id rhye-1  --fees 100uqck -y
```

#### Vote 'Abstain'

```
quicksilverd tx gov vote 1 abstain --from $WALLET --chain-id rhye-1  --fees 100uqck -y
```

#### Vote 'NoWithVeto'

```
quicksilverd tx gov vote 1 no_with_veto --from $WALLET --chain-id rhye-1 --fees 100uqck -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.quicksilver/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.quicksilver/config/app.toml
```

#### Update Indexer

**Disable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "null"|' $HOME/.quicksilver/config/config.toml
```

**Enable indexer**

```
sed -i -e 's|^indexer *=.*|indexer = "kv"|' $HOME/.quicksilver/config/config.toml
```

#### Update pruning

```
sed -i \
  -e 's|^pruning *=.*|pruning = "custom"|' \
  -e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
  -e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
  -e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
  $HOME/.quicksilver/config/app.toml
```

***

## 🚨 Maintenance

#### Get validator info

```
quicksilverd status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
quicksilverd status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(quicksilverd tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.sge/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Check if validator key is correct

```
[[ $(quicksilverd q staking validator $(quicksilverd keys show wallet --bech val -a) -oj | jq -r .consensus_pubkey.key) = $(stchaind status | jq -r .ValidatorInfo.PubKey.value) ]] && echo -e "\n\e[1m\e[32mTrue\e[0m\n" || echo -e "\n\e[1m\e[31mFalse\e[0m\n"
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
quicksilverd tendermint unsafe-reset-all --keep-addr-book --home $HOME/.quicksilver --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop quicksilverd
sudo systemctl disable quicksilverd
sudo rm -rf /etc/systemd/system/quicksilverd.service
sudo rm $(which quicksilverd)
sudo rm -rf $HOME/.quicksilverd
sed -i "/QUICKSILVER_/d" $HOME/.bash_profile
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable quicksilverd
```

#### Disable service

```
sudo systemctl disable quicksilverd
```

#### Start service

```
sudo systemctl start quicksilverd
```

#### Stop service

```
sudo systemctl stop quicksilverd
```

#### Restart service

```
sudo systemctl restart quicksilverd
```

#### Check service status

```
sudo systemctl status quicksilverd
```

#### Check service logs

```
sudo journalctl -u quicksilverd -f --no-hostname -o cat
```


# Swisstronik

Stake with LOGOSNODOS

{% embed url="<https://explorer-cosmos.testnet.swisstronik.com/swisstronik/staking/swtrvaloper1jc9was3a9uh9whcl9av3lx95ar56jj5q6mc57s>" %}

<figure><img src="/files/2ptiuWVO2Ege8wsujOpf" alt=""><figcaption></figcaption></figure>

Swisstronik is a layer 1 solution built on the Cosmos SDK framework. It aims to combine the benefits of the Ethereum Virtual Machine (EVM) with the underlying infrastructure provided by the Cosmos SDK. This integration allows Swisstronik to offer Ethereum compatibility while providing additional features such as private EVM execution using Intel SGX.

**Website** : [https://swisstronik.com](https://swisstronik.com/)

**Twitter** : <https://twitter.com/swisstronik>

**Discord** : <https://discord.gg/e7cNGJ9REz>

**Linkedin :** [https://www.linkedin.com/company/swisstronik](https://www.linkedin.com/company/swisstronik/)

**Facebook :** <https://www.facebook.com/swisstronik>

**Documentation** : [https://swisstronik.gitbook.io](https://swisstronik.gitbook.io/)


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: swisstronik\_1291-1 | **Latest Version Tag**: v1.1.1 | **Wasm**: OFF

{% hint style="info" %}
Before installing the node you should enable SGX and confirm your system ready by installing SGX and obtain masterkey : \
<https://swisstronik.gitbook.io/swisstronik-docs/node-setup/setup-sgx/setup-intel-sgx>
{% endhint %}

## Installation

## Install dependencies

**Setting up variable**

```
echo "export SWISSTRONIK_CHAIN_ID=swisstronik_1291-1" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.21.4.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Download and build binaries**

```
cd $HOME
wget https://github.com/SigmaGmbH/swisstronik-chain/releases/download/v1.0.1/swisstronikd.deb.zip 
unzip swisstronikd.deb.zip  
dpkg -i swisstronik_1.0.1-updated-binaries_amd64.deb
swisstronikd version
```

**Change your moniker**&#x20;

```
swisstronikd init <Moniker> --chain-id=swisstronik_1291-1
```

**Download Genesis**

```
curl https://rpc.testnet.swisstronik.com/genesis? | jq ".result.genesis" > ~/.swisstronik/config/genesis.json
```

#### Set the gas prices

```
sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"7uswtr\"/;" ~/.swisstronik/config/app.toml
external_address=$(wget -qO- eth0.me) 
sed -i.bak -e "s/^external_address *=.*/external_address = \"$external_address:26656\"/" $HOME/.swisstronik/config/config.toml
sed -i.bak -e "s/^seeds =.*/seeds = \"$seeds\"/" $HOME/.swisstronik/config/config.toml
```

#### Specify prunning option

```
pruning="custom" && \
pruning_keep_recent="100" && \
pruning_keep_every="0" && \
pruning_interval="10" && \
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" ~/.swisstronik/config/app.toml && \
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" ~/.swisstronik/config/app.toml && \
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" ~/.swisstronik/config/app.toml && \
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" ~/.swisstronik/config/app.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/swisstronikd.service > /dev/null <<EOF
[Unit]
Description=Swisstronik
After=network-online.target

[Service]
User=$USER
ExecStart=$(which swisstronikd) start
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable swisstronikd
```

#### Start service and check the logs

```
sudo systemctl start swisstroonikd && sudo journalctl -u swisstronikd -f --no-hostname -o cat
```

{% hint style="danger" %}
If you got enclave error you should obtain master key :&#x20;

```
mkdir $HOME/.swisstronik-enclave/
sudo cp /usr/lib/enclave.signed.so $HOME/.swisstronik-enclave/
swisstronikd enclave request-master-key rpc.testnet.swisstronik.com:46789
```

{% endhint %}


# Cheat Sheet

## Key management

{% hint style="info" %}
If you got an error "Error: provided algorithm "eth\_secp256k1" is not supported", specify an additional parameter for keyring `--keyring-backend test` or `--keyring-backend file`
{% endhint %}

#### Add new key

```
swisstronikd keys add wallet
```

#### Recover existing key

```
swisstronikd keys add wallet --recover
```

#### List all keys

```
swisstronikd keys list
```

#### Delete key

```
swisstronikd keys delete wallet
```

#### Export key to the file

```
swisstronikd keys export wallet
```

#### Import key from the file

```
swisstronikd keys import wallet wallet.backup
```

#### Query wallet balance

```
swisstronikd q bank balances $(sged keys show wallet -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity**, **details** and **website** to match your values.
{% endhint %}

#### Create new validator

```
swisstronikd tx staking create-validator \
  --amount 1000000uswtr \
  --commission-max-change-rate "0.1" \
  --commission-max-rate "0.2" \
  --commission-rate "0.1" \
  --min-self-delegation "1" \
  --pubkey  $(swisstronikd tendermint show-validator) \
  --moniker "<your moniker>" \
  --website "<your website>" \
  --identity "<your identity> \
  --details "<your descriptions> \
  --chain-id $SWISSTRONIK_CHAIN_ID \
  --gas-prices 7uswtr \
  --from wallet \
  -y
```

#### Edit existing validator

```
swisstronikd tx staking edit-validator \
  --moniker=<your moniker> \
  --identity=<your_keybase_id> \
  --website=<your_website> \
  --details=<your_validator_description> \
  --chain-id=$SWISSTRONIK_CHAIN_ID \
  --from=wallet \
  -y
```

#### Unjail validator

```
swisstronikd tx slashing unjail \
  --broadcast-mode=block \
  --chain-id=$SWISSTRONIK_CHAIN_ID \
  --gas=auto \
  --from=wallet \
  -y
```

#### View validator details

```
swisstronikd q staking validator $(swisstronikd keys show wallet --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
swisstronikd tx distribution withdraw-all-rewards --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Withdraw commission and rewards from your validator

```
swisstronikd tx distribution withdraw-rewards $(swisstronikd keys show wallet --bech val -a) --commission --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Delegate tokens to yourself

```
swisstronikd tx staking delegate $(swisstronikd keys show wallet --bech val -a) 10000000uswtr --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Redelegate tokens to another validator

```
swisstronikd tx staking redelegate $(swisstronikd keys show wallet --bech val -a) <TO_VALOPER_ADDRESS> 10000000usge --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Unbond tokens from your validator

```
swisstronikd tx staking unbond $(swisstronikd keys show wallet --bech val -a) 1000000usge --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Send tokens to the wallet

```
swisstronikd tx bank send wallet <TO_WALLET_ADDRESS> 1000000usge --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

***

## Governance

#### List all proposals

```
swisstronikd query gov proposals
```

#### View proposal by id

```
swisstronikd query gov proposal 1
```

#### Vote 'Yes'

```
swisstronikd tx gov vote 1 yes --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Vote 'No'

```
swisstronikd tx gov vote 1 no --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Vote 'Abstain'

```
swisstronikd tx gov vote 1 abstain --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

#### Vote 'NoWithVeto'

```
swisstronikd tx gov vote 1 NoWithVeto --from wallet --chain-id $SWISSTRONIK_CHAIN_ID --gas-adjustment 1.4 --gas auto --gas-prices 7uswtr -y
```

***

## Utility

#### Update ports

```
CUSTOM_PORT=110
sed -i -e "s%^proxy_app = \"tcp://127.0.0.1:26658\"%proxy_app = \"tcp://127.0.0.1:${CUSTOM_PORT}58\"%; s%^laddr = \"tcp://127.0.0.1:26657\"%laddr = \"tcp://127.0.0.1:${CUSTOM_PORT}57\"%; s%^pprof_laddr = \"localhost:6060\"%pprof_laddr = \"localhost:${CUSTOM_PORT}60\"%; s%^laddr = \"tcp://0.0.0.0:26656\"%laddr = \"tcp://0.0.0.0:${CUSTOM_PORT}56\"%; s%^prometheus_listen_addr = \":26660\"%prometheus_listen_addr = \":${CUSTOM_PORT}66\"%" $HOME/.swisstronik/config/config.toml
sed -i -e "s%^address = \"tcp://0.0.0.0:1317\"%address = \"tcp://0.0.0.0:${CUSTOM_PORT}17\"%; s%^address = \":8080\"%address = \":${CUSTOM_PORT}80\"%; s%^address = \"0.0.0.0:9090\"%address = \"0.0.0.0:${CUSTOM_PORT}90\"%; s%^address = \"0.0.0.0:9091\"%address = \"0.0.0.0:${CUSTOM_PORT}91\"%" $HOME/.swisstronik/config/app.toml
```

#### Get sync info

```
swisstronikd status 2>&1 | jq .SyncInfo
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Enable prometheus

```
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.swisstronik/config/config.toml
```

#### Reset chain data

```
swisstronikd tendermint unsafe-reset-all --keep-addr-book --home $HOME/.swisstronik --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
cd $HOME
sudo systemctl stop swisstronikd
sudo systemctl disable swisstronikd
sudo rm /etc/systemd/system/swisstronikd.service
sudo systemctl daemon-reload
rm -f $(which swisstronikd)
rm -rf $HOME/.swisstronik
rm -rf $HOME/swisstronik
```


# Symphony

Stake with LOGOSNODOS

{% embed url="<https://testnet.airchains.io/validator/airvaloper1mugsjk6e553j7ynwm5gyk27wfqcz4qm7je5pqs>" %}

RPC :&#x20;

```
https://symphony-testnet-rpc.logosnodos.me/
```

API :&#x20;

```
https://symphony-testnet-api.logosnodos.me/
```

<figure><img src="/files/MyCe1oEWvuZl6q0mbsbV" alt=""><figcaption></figcaption></figure>

Seamlessly zk for unmatched speed and privacy with zkRollup Framework, with diverse options for execution and data availability.

**Website :** <https://www.airchains.io/>

**Twitter :** <https://x.com/airchains_io>

**Discord :** <https://discord.com/invite/airchains>

**Documentation :** <https://docs.airchains.io/>


# Installation

The complete infrastructure for cross-chain smart contracts, applications, and modular functionality.

**Chain ID**: zgtendermint\_16600-1 | **Latest Version Tag**:  | **Wasm**:&#x20;

## Installation

## Install dependencies

**Update system and install build tools**

```
sudo apt -q update
sudo apt -qy install curl git jq lz4 build-essential tmux libgmp3-dev flex bison
sudo apt -qy upgrade
```

**Install Go**

```
rm -rf $HOME/go
sudo rm -rf /usr/local/go
cd $HOME
curl https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
EOF
source $HOME/.profile
go version
```

**Set Variable**

```
echo "export SYMPHONY_WALLET="YOUR WALLET NAME"" >> $HOME/.bash_profile
echo "export MONIKER="YOUR NODE NAME"" >> $HOME/.bash_profile
echo "export SYMPHONY_CHAIN_ID="symphony-testnet-2"" >> $HOME/.bash_profile
echo "export SYMPHONY_PORT="12"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

**Download and build binaries**

```
cd $HOME
git clone https://github.com/Orchestra-Labs/symphony.git
cd symphony
git checkout v0.2.1
make install
```

Set config and init app

```
symphonyd init $MONIKER --chain-id $SYMPHONY_CHAIN_ID 
sed -i -e "s|^node *=.*|node = \"tcp://localhost:${SYMPHONY_PORT}657\"|" $HOME/.symphonyd/config/client.toml
```

#### Set genesis and address book

```
curl -Ls https://snapshot.sychonix.com/symphony/genesis.json > $HOME/.symphonyd/config/genesis.json 
curl -Ls https://snapshot.sychonix.com/symphony/addrbook.json > $HOME/.symphonyd/config/addrbook.json
```

#### Set custom ports in app.toml

```
sed -i.bak -e "s%:1317%:${SYMPHONY_PORT}317%g;
s%:8080%:${SYMPHONY_PORT}080%g;
s%:9090%:${SYMPHONY_PORT}090%g;
s%:9091%:${SYMPHONY_PORT}091%g;
s%:8545%:${SYMPHONY_PORT}545%g;
s%:8546%:${SYMPHONY_PORT}546%g;
s%:6065%:${SYMPHONY_PORT}065%g" $HOME/.symphonyd/config/app.toml
```

#### Set custom ports in config.toml

```
sed -i.bak -e "s%:26658%:${SYMPHONY_PORT}658%g;
s%:26657%:${SYMPHONY_PORT}657%g;
s%:6060%:${SYMPHONY_PORT}060%g;
s%:26656%:${SYMPHONY_PORT}656%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${SYMPHONY_PORT}656\"%;
s%:26660%:${SYMPHONY_PORT}660%g" $HOME/.symphonyd/config/config.toml
```

#### Config pruning

```
sed -i \
  -e 's|^pruning *=.*|pruning = "custom"|' \
  -e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
  -e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
  -e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
  $HOME/.symphonyd/config/app.toml
```

#### Set minimum gas price, enable prometheus and disable indexing

```
sed -i -e "s|^minimum-gas-prices *=.*|minimum-gas-prices = \"0note\"|" $HOME/.symphonyd/config/app.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.symphonyd/config/config.toml
```

#### Create a service

```
sudo tee /etc/systemd/system/symphonyd.service > /dev/null <<EOF
[Unit]
Description=symphonyd
After=network-online.target
[Service]
User=$USER
ExecStart=$(which symphonyd) start
Restart=always
RestartSec=3
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

#### Start service and check the logs

```
sudo systemctl daemon-reload
sudo systemctl enable symphonyd
sudo systemctl restart symphonyd && sudo journalctl -u symphonyd -f -o cat
```


# Cheat Sheet

## Key management

#### Add new key

```
symphonyd keys add $SYMPHONY_WALLET
```

#### Recover existing key

```
symphonyd keys add $SYMPHONY_WALLET --recover
```

#### List all keys

```
symphonyd keys list
```

#### Delete key

```
symphonyd keys delete $SYMPHONY_WALLET
```

#### Export key to the file

```
symphonyd keys export $SYMPHONY_WALLET
```

#### Import key from the file

```
symphonyd keys import $SYMPHONY_WALLET wallet.backup
```

#### Query wallet balance

```
symphonyd q bank balances $(symphonyd keys show $SYMPHONY_WALLET -a)
```

***

## Validator management

{% hint style="info" %}
Please make sure you have adjusted **moniker**, **identity and** **details** to match your values.
{% endhint %}

#### Create new validator

```
symphonyd tx staking create-validator \
  --amount 1000000note \
  --from $WALLET \
  --commission-max-change-rate "0.01" \
  --commission-max-rate "0.2" \
  --commission-rate "0.1" \
  --min-self-delegation "1" \
  --pubkey  $(symphonyd tendermint show-validator) \
  --moniker $NODENAME \
  --chain-id $SYMPHONY_CHAIN_ID
  --gas-adjustment 1.4 \
  --gas auto \
  --fees 800note
```

#### Edit existing validator

```
symphonyd tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "" \
--identity "" \
--details "" \
--from $SYMPHONY_WALLET \
--chain-id $SYMPHONY_CHAIN_ID \
--fees 200note \
-y 
```

#### Unjail validator

```
symphonyd tx slashing unjail --from $SYMPHONY_WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### List all active validators

```
symphonyd q staking validators -oj --limit=2000 | jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' | jq -r '(.tokens|tonumber/pow(10; 6)|floor|tostring) + " 	 " + .description.moniker' | sort -gr | nl
```

#### View validator details

```
symphonyd q staking validator $(symphonyd keys show $SYMPHONY_WALLET --bech val -a)
```

***

## Token management

#### Withdraw rewards from all validators

```
symphonyd tx distribution withdraw-all-rewards --from $SYMPHONY_WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note 
```

#### Withdraw commission and rewards from your validator

```
symphonyd tx distribution withdraw-rewards <your_valoper-address> --from $SYMPHONY_WALLET --commission --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Delegate tokens to yourself

```
symphonyd tx staking delegate $(symphonyd keys show $SYMPHONY_WALLET --bech val -a) 1000000note --from $SYMPHONY_WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Delegate tokens to validator

```
symphonyd tx staking delegate <TO_VALOPER_ADDRESS> 1000000amf --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 	
```

#### Redelegate tokens to another validator

```
symphonyd tx staking redelegate $VALOPER_ADDRESS <TO_VALOPER_ADDRESS> 1000000amf --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Unbond tokens from your validator

```
symphonyd tx staking unbond $(symphonyd keys show $WALLET --bech val -a) 1000000amf --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Send tokens to the wallet

```
symphonyd tx bank send $WALLET_ADDRESS <TO_WALLET_ADDRESS> 1000000note --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

***

## Governance

#### List all proposals

```
symphonyd query gov proposals
```

#### View proposal by id

```
symphonyd query gov proposal 1
```

#### Vote 'Yes'

```
symphonyd tx gov vote 1 yes --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Vote 'No'

```
symphonyd tx gov vote 1 no --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Vote 'Abstain'

```
symphonyd tx gov vote 1 abstain --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

#### Vote 'NoWithVeto'

```
symphonyd tx gov vote 1 no_with_veto --from $WALLET --chain-id $SYMPHONY_CHAIN_ID --fees 200note -y 
```

***

## 🚨 Maintenance

#### Get validator info

```
symphonyd status 2>&1 | jq .ValidatorInfo
```

#### Get sync info

```
symphonyd status 2>&1 | jq .SyncInfo
```

#### Get node peer

```
echo $(symphonyd tendermint show-node-id)'@'$(curl -s ifconfig.me)':'$(cat $HOME/.symphonyd/config/config.toml | sed -n '/Address to listen for incoming connection/{n;p;}' | sed 's/.*://; s/".*//')
```

#### Get live peers

```
curl -sS http://localhost:26657/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}'
```

#### Reset chain data

```
symphonyd tendermint unsafe-reset-all --keep-addr-book --home $HOME/.symphonyd --keep-addr-book
```

#### Remove node

{% hint style="danger" %}
Please, before proceeding with the next step! All chain data will be lost! Make sure you have backed up your **priv\_validator\_key.json** !
{% endhint %}

```
sudo systemctl stop symphonyd
sudo systemctl disable symphonyd 
sudo rm -rf /etc/systemd/system/symphonyd.service
sudo rm $(which symphonyd)
sudo rm -rf $HOME/.symphonyd 
sed -i "/AIRCHAIN_/d" $HOME/.bash_profile
```

***

## Service Management

#### Reload service configuration

```
sudo systemctl daemon-reload
```

#### Enable service

```
sudo systemctl enable symphonyd 
```

#### Disable service

```
sudo systemctl disable symphonyd 
```

#### Start service

```
sudo systemctl start symphonyd 
```

#### Stop service

```
sudo systemctl stop symphonyd 
```

#### Restart service

```
sudo systemctl restart symphonyd 
```

#### Check service status

```
sudo systemctl status symphonyd 
```

#### Check service logs

```
sudo journalctl -u symphonyd -f --no-hostname -o cat
```


# PEARL

## What is PEARL?

PEARL is a Proof-of-Useful-Work Layer 1 blockchain built for the AI compute era.

Instead of using energy only for random hashing like traditional Proof-of-Work networks, PEARL turns GPU computation into useful work. Its mining process is based on matrix multiplication, the core operation behind modern AI training and inference.

In simple terms:

> PEARL transforms AI compute into a monetary network.

This means the same GPU cycles used for AI workloads can also help secure the PEARL network and generate mining rewards.

***

### Why PEARL Matters

AI is becoming one of the largest consumers of global compute and energy. At the same time, traditional Proof-of-Work blockchains spend massive amounts of energy on computations that do not directly produce useful output.

PEARL introduces a different model.

Instead of separating AI compute and blockchain mining, PEARL connects them into one system:

* AI workloads produce useful computation
* Useful computation helps secure the network
* Miners receive PEARL rewards
* The network becomes stronger as more GPU compute joins
* AI infrastructure gains an additional revenue stream

This creates a new economic loop between energy, compute, and money.

***

### Proof-of-Useful-Work

PEARL uses Proof-of-Useful-Work, or PoUW.

In traditional Proof-of-Work, miners compete by performing random hashing. In PEARL, miners perform verifiable matrix multiplication, a real computation used heavily in AI.

Matrix multiplication is important because it powers many AI processes, including:

* Model training
* Model inference
* Neural networks
* Large-scale GPU workloads

PEARL’s goal is to make mining useful by aligning blockchain security with the work already being done by AI infrastructure.

***

### The “Two-for-One” Idea

PEARL is designed around a simple idea:

> One GPU operation can support both AI computation and blockchain mining.

This is why PEARL is often described as a “two-for-one” system.

A GPU provider can run AI workloads while also producing mining work for the PEARL network. This allows useful compute to become part of the blockchain’s security model.

For AI companies and GPU operators, PEARL can create a parallel revenue stream from compute that is already being used.

***

### How PEARL is Different

PEARL is not just another AI token.

It is designed as an L1 blockchain where the mining process itself is connected to real AI computation.

Key differences:

* PEARL replaces random hashing with useful GPU work
* Mining is based on matrix multiplication
* The network is designed around AI infrastructure
* GPU compute becomes part of the monetary system
* The blockchain keeps a Bitcoin-inspired security model while adapting it for AI workloads

PEARL’s core thesis is simple:

> Bitcoin turned electricity into digital money.\
> PEARL turns AI compute into digital money.

***

### Security and Verification

PEARL is designed so that useful computation can be verified without exposing sensitive data.

This matters because AI workloads may involve private model weights, proprietary data, or user-related inputs.

The whitepaper describes privacy and zero-knowledge techniques as part of the design direction, allowing the network to verify that computation happened without leaking the underlying inputs.

The goal is to keep mining fair, verifiable, and compatible with real-world AI workloads.

***

### PEARL Blockchain Overview

PEARL follows a Bitcoin-inspired blockchain structure.

It uses:

* A UTXO-based ledger
* Proof-of-Work style consensus
* Blocks containing transactions and proof data
* Miner rewards through newly minted PEARL and transaction fees
* A longest-chain rule based on cumulative work

This gives PEARL a familiar foundation while changing what mining actually does.

Instead of proving work through meaningless hashing, PEARL proves work through AI-relevant computation.

***

### Token and Network Design

According to the whitepaper, PEARL has:

* Total supply: 2,100,000,000 PEARL
* Smallest unit: 0.00000001 PEARL, called a grain
* Block time: approximately 194 seconds
* Emission model: smooth, polynomially decaying issuance

The emission design is intended to avoid sharp halving shocks while still preserving long-term scarcity.

***

### Future Direction

PEARL’s current design focuses on exact integer matrix multiplication.

The whitepaper also discusses future upgrades to support modern low-precision AI workloads such as BF16, FP8, and FP4, which are widely used in AI training and inference.

This matters because AI infrastructure is constantly evolving toward faster and more efficient computation.

PEARL aims to evolve with that trend.

***

### Simple Explanation for New Users

PEARL is a blockchain that rewards useful AI computation.

Instead of wasting GPU power on random mining, PEARL allows GPU work used in AI to also secure a decentralized network.

This connects three things into one system:

* Energy
* AI compute
* Digital money

That is the core idea of PEARL.

***

### One-Line Description

PEARL is a Proof-of-Useful-Work L1 blockchain that turns AI GPU computation into a decentralized monetary network.

***

### Short Community Pitch

PEARL is built for the AI compute era.

Traditional Proof-of-Work turns electricity into digital money through random hashing. PEARL takes the next step by using the core operation behind AI — matrix multiplication — as the foundation for mining.

This means GPU compute can do useful AI work while also securing the PEARL network.

PEARL is not just an AI narrative. It is a new way to connect compute, energy, and money.


# $PEARL Mining Tutorial

## One command line (Non-Docker)

* Pearl Hash

```
apt update && apt install -y curl ca-certificates gnupg && curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && apt install -y nodejs && npm install -g pm2 && cd /root && curl -L https://pearlhash.xyz/downloads/pearl-miner-v6 -o /root/pearl-miner && chmod +x /root/pearl-miner && WORKER=${RUNPOD_POD_ID:-$(hostname)} && pm2 start "/root/pearl-miner --host 84.32.220.219:9000 --user prl1ptpm8ap22tdammltjufep5hm7v9lg8s0lfdd3f6yv0uvhlhckeuaqvts9qk --worker $WORKER" --name "pearl-$WORKER" && pm2 save && pm2 startup systemd -u root --hp /root
```

* Alpha Mine

```
# 1) Download the miner — source: https://github.com/AlphaMine-Tech/alpha-miner
# Linux x86_64, supports Volta/Ampere/Ada/Hopper/Blackwell auto-detect
curl -L -o alpha-miner https://pearl.alphapool.tech/downloads/alpha-miner
chmod +x alpha-miner

# 2) Replace YOUR_PRL_ADDRESS with your prl1p... wallet address, then run
./alpha-miner \
  --pool stratum+tcp://us2.alphapool.tech:5566 \
  --address prl1pYOUR_PRL_ADDRESS \
  --worker rig01
```

* Akoya Pool

```
1. Create a RunPod account -> Sign up on RunPod
2. Create a template -> Go to Pods → Templates → New Template and set:
# Template config — create once, reuse for every pod.
Container Image: registry.akoyapool.com/akoya-miner:latest
Environment Variables:
  AKOYA_POOL_WALLET = YOUR_PEARL_ADDRESS
  AKOYA_POOL_WORKER = runpod-rig-01
copy
Replace YOUR_PEARL_ADDRESS with your prl1… address.
3. Deploy a pod
```

* Mineprl

```
curl -fL --progress-bar -O https://pool.mineprl.com/dl/mineprl-worker-blackwell-rtx-v1.3-linux-x86_64.tar.zst
zstd -d mineprl-worker-blackwell-rtx-v1.3-linux-x86_64.tar.zst -c | tar -x

cd mineprl-worker-blackwell-rtx-v1.3-linux-x86_64
sudo ./start_mining.sh \
  --address YOUR_PEARL_ADDRESS \
  --label WORKER_NAME
```

If the process is successful, you will see the text `Project created` 🎉


# $PEARL Bridge

Use [PearlBridge](https://pearlbridge.xyz) to swap native PRL ↔ WPRL (ERC-20 on Ethereum) at **1:1**.

> WPRL contract on Ethereum: `0x07696DcaB55E62cfef953666b29Fe1970518cB00` — always verify on [Etherscan](https://etherscan.io/token/0x07696DcaB55E62cfef953666b29Fe1970518cB00).

### Quick facts

|          | PRL → WPRL                               | WPRL → PRL                           |
| -------- | ---------------------------------------- | ------------------------------------ |
| Fee      | 0.5% (min 4 PRL)                         | None (just ETH gas)                  |
| Speed    | \~20 min (fast lane) or 24 h (slow lane) | Minutes after burn confirms          |
| You need | Pearl wallet + Ethereum wallet           | WPRL + ETH for gas + `prl1…` address |

### PRL → WPRL (Pearl → Ethereum)

Lock native PRL on Pearl, receive WPRL on Ethereum.

1. Open [pearlbridge.xyz](https://pearlbridge.xyz) and keep the toggle on **PRL → WPRL**.
2. Click **Sign in** (top right) and connect your Ethereum wallet.
3. Enter the amount in **AMOUNT (PRL)** and click **Continue**.
4. Copy the **deposit address** the bridge gives you.
5. From your Pearl wallet, send the **exact amount** of PRL to that address.
6. Wait \~20 min (fast lane) — WPRL lands in your Ethereum wallet automatically.

> Fee example: bridging 1,000 PRL → 0.5 % = 5 PRL → you receive **995 WPRL**.

### WPRL → PRL (Ethereum → Pearl)

Burn WPRL on Ethereum, receive native PRL on Pearl. **No bridge fee** — you only pay ETH gas.

1. Switch the toggle to **WPRL → PRL**.
2. Connect the Ethereum wallet that holds your WPRL.
3. Enter the amount and paste your **`prl1…` Pearl address**.
4. Click **Burn WPRL** and confirm in your wallet (pay ETH gas).
5. Native PRL arrives at your Pearl address within minutes.

> Double-check your `prl1…` address — Pearl transactions are irreversible.

### Fast lane vs slow lane

* **Fast lane** — first 100,000 PRL bridged per 24 h window → minted in \~20 min (6 Pearl confirmations).
* **Slow lane** — any tx > 100,000 PRL, or once the daily fast-lane quota is full → 24 h timelock. Settles automatically, no action required.

Check **Fast Lane Left** on the bridge homepage to know which lane you'll be in.

### Safety

* 1:1 backing — verify live solvency at [pearlbridge.xyz/audit](https://pearlbridge.xyz/audit).
* Always verify the WPRL contract address before approving spends: `0x07696DcaB55E62cfef953666b29Fe1970518cB00`.
* Test with a **small amount** first.


# $PEARL Market

1. [Lords of Pearls OTC](https://t.me/LOPOTCBOT?start=ref_TNsFhFyx)

The first Telegram-native PRL/USDC OTC desk. Instant settlement on an off-chain ledger, the lowest fee on the market today (1.8% on the seller leg, 0% on the buyer leg for the current 24-hour promo), zero slippage, 2FA on every withdrawal, zero slippage, and a 15% lifetime referral on every fee your invitees ever pay.

Lord Of Pearls OTC is a Telegram-based OTC desk for PRL/USDC trading.

**Key advantages:**

* Instant settlement through an off-chain ledger
* 0% slippage
* Low trading fees
* 2FA for withdrawals
* 15% lifetime referral from the fees generated by invited users
* Suitable for active traders who want a fast process

2. [Black Pearl Market](https://t.me/BlackPearlMarket_bot?start=ref_4a6738b5bb)

BlackPearlMarket is a custodial PRL/USDC exchange available through both web and Telegram bot + it has PRC20 features launching recently.

**Key advantages:**

* Accessible through web and Telegram
* Fast settlement through a custodial ledger
* Lifetime referral program available
* PRC20 Inscription

&#x20;

3. [PearlOTC](https://pearl-otc.com/marketplace)

Pearl OTC is a non-custodial platform based on atomic swaps. Each trade uses a 2-of-2 Taproot escrow on the Pearl network, while the buy side is settled using USDC on Arbitrum.

**Key advantages:**

* Stronger custody model because the operator does not fully control user funds
* Non-custodial
* Suitable for larger trades where security is the main priority

4. [SafeTrade](https://safetrade.com/exchange/PRL-USDT)

SafeTrade is a simple safety framework for community members who want to buy or sell PRL/USDT. The goal is to help users trade safely, avoid scams, and reduce mistakes during the selling process.

SafeTrade does not mean that trading is risk-free. It means following a clear checklist before, during, and after every transaction.

5. Uniswap

Link : <https://app.uniswap.org/swap?outputCurrency=0x07696DcaB55E62cfef953666b29Fe1970518cB00&chain=ethereum>


# Hardhat

<figure><img src="/files/ZyOejy8Y1FjaEYYDxSPI" alt=""><figcaption></figcaption></figure>

Hardhat is a development environment for Ethereum software. It consists of different components for editing, compiling, debugging and deploying your smart contracts and dApps, all of which work together to create a complete development environment.

Hardhat Runner is the main component you interact with when using Hardhat. It's a flexible and extensible task runner that helps you manage and automate the recurring tasks inherent to developing smart contracts and dApps.

Hardhat Runner is designed around the concepts of **tasks** and **plugins**. Every time you're running Hardhat from the command-line, you're running a task. For example, `npx hardhat compile` runs the built-in `compile` task. Tasks can call other tasks, allowing complex workflows to be defined. Users and plugins can override existing tasks, making those workflows customizable and extendable.


# Installation

## Setting Up The Environment

{% hint style="warning" %}
Make sure you have installed [Node.js](https://nodejs.org/en/download) and [npm ](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)on your system before proceeding with this guide.
{% endhint %}

1. Install Hardhat

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

2. Create a Hardhat project

```
npx hardhat
```

3. Press enter on `Create a JavaScript project`

```
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.17.1

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

```

{% hint style="info" %}
Make sure you install the hardhat toolbox by running
{% endhint %}

```
npm install --save-dev @nomicfoundation/hardhat-toolbox
```

If the process is successful, you will see the text `Project created` 🎉


# Setup Hardhat on Swisstronik Network

After successfully setting up your Hardhat project, the next step is to configure the hardhat.config.js file. This will be the essential configuration file where you can customize the networks, plugins, compiler settings, and more.&#x20;

1. Open the `hardhat.config.js` file

<figure><img src="/files/xYusrwiQ3sHNZ7gqSNzA" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
For the scope of this tutorial, we will only configure the **networks**, leaving the solidity compiler at its default version 0.8.19.
{% endhint %}

2. Setup the Swisstronik's network

```
require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  solidity: "0.8.19",
  networks: {
    swisstronik: {
      url: "https://json-rpc.testnet.swisstronik.com/", //URL of the RPC node for Swisstronik.
      accounts: ["0xd5..."], //Your private key starting with "0x" 
      //Make sure you have enough funds in this wallet to deploy the smart contract
    },
  },
};
```

{% hint style="warning" %}
Make sure you have enough funds in this wallet to deploy/interact with the smart contract. otherwise, you can [get SWTR test tokens here](broken://pages/CncfQNTEeNhjLT843y9B)
{% endhint %}


# Write and compile the smart contract

{% hint style="info" %}
For the scope of this tutorial, we will publish a simple "Hello Swisstronik" smart contract with only 2 functions -one for writing to the blockchain and one for reading from the blockchain- with 1 state variable.
{% endhint %}

1. Go to the contracts folder and open the `.sol` file (smart contract).

We renamed it to `Hello_swtr.sol`

<figure><img src="/files/SnkXmm8ctkhDoBRcYm8Y" alt=""><figcaption></figcaption></figure>

2. Paste the smart contract into your `Hello_swtr.sol` file.

{% hint style="danger" %}
Currently, only support Solidity compilers up to 0.8.19
{% endhint %}

```
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;

//This contract is only intended for testing purposes

contract Swisstronik {
    string private message;

    /**
     * @dev Constructor is used to set the initial message for the contract
     * @param _message the message to associate with the message variable.
     */
    constructor(string memory _message) payable{
        message = _message;
    }

    /**
     * @dev setMessage() updates the stored message in the contract
     * @param _message the new message to replace the existing one
     */
    function setMessage(string memory _message) public {
        message = _message;
    }

    /**
     * @dev getMessage() retrieves the currently stored message in the contract
     * @return The message associated with the contract
     */
    function getMessage() public view returns(string memory){
        return message;
    }
}
```

3. Compile the contract

To compile the smart contract, run `npx hardhat compile`  in your terminal (if you are using VSCode, you can open a new terminal with *Ctrl + Shift + \`* )

After successful compilation:

1. You should get the message *Compiled 1 Solidity file successfully* in your terminal
2. A new *artifacts* folder should be created

<figure><img src="/files/U94nYHYSVAejstoqZZlo" alt=""><figcaption></figcaption></figure>

Now you are ready to deploy this contract on Swisstronik! 🚀&#x20;


# Deploy the smart contract

1. Go to the `deploy.js` file located in the scripts folder

<figure><img src="/files/bHf3Kex8FuLSO9DpTiTd" alt=""><figcaption></figcaption></figure>

2. Paste the deployment script in the `deploy.js` file

```
const hre = require("hardhat");

async function main() {
  /**
   * @dev make sure the first argument has the same name as your contract in the Hello_swtr.sol file
   * @dev the second argument must be the message we want to set in the contract during the deployment process
   */
  const contract = await hre.ethers.deployContract("Swisstronik", ["Hello Swisstronik!!"]);

  await contract.waitForDeployment();

  console.log(`Swisstronik contract deployed to ${contract.target}`);
}

//DEFAULT BY HARDHAT:
// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

3. Deploy the contract by running `npx hardhat run scripts/deploy.js --network swisstronik`

{% hint style="warning" %}
Please make sure that the network command corresponds exactly to the name specified in your hardhat.config.js file (in this case: "swisstronik").
{% endhint %}

After successful deployment, you should receive the following message in your terminal:

&#x20;`Swisstronik contract deployed to 0x...`&#x20;

Awesome, now let's start interacting with the contract! 🎉


# Interact with the contract-Transaction

{% hint style="info" %}
Make sure you have installed SwisstronikJS by running `npm i @swisstronik/swisstronik.js`
{% endhint %}

1. Within the scripts folder, create a file called `setMessage.js`

<figure><img src="/files/3RSdgapa3kzJfVJ01TNg" alt=""><figcaption></figcaption></figure>

2. Let's write our `setMessage.js` script

* Import hardhat and swisstronikJS functions

```
const hre = require("hardhat");
const { encryptDataField, decryptNodeResponse } = require("@swisstronik/swisstronik.js");
```

* Let's use `sendShieldedTransaction` to send a call/query to the blockchain

```
/**
 * Send a shielded transaction to the Swisstronik blockchain.
 *
 * @param {object} signer - The signer object for sending the transaction.
 * @param {string} destination - The address of the contract to interact with.
 * @param {string} data - Encoded data for the transaction.
 * @param {number} value - Amount of value to send with the transaction.
 *
 * @returns {Promise} - The transaction object.
 */
const sendShieldedTransaction = async (signer, destination, data, value) => {
  // Get the RPC link from the network configuration
  const rpclink = hre.network.config.url;

  // Encrypt transaction data
  const [encryptedData] = await encryptDataField(rpclink, data);

  // Construct and sign transaction with encrypted data
  return await signer.sendTransaction({
    from: signer.address,
    to: destination,
    data: encryptedData,
    value,
  });
};
```

* Write the `main` script to use `sendShieldedTransaction` function

```
async function main() {
  // Address of the deployed contract
  const contractAddress = "0xf84Df872D385997aBc28E3f07A2E3cd707c9698a";

  // Get the signer (your account)
  const [signer] = await hre.ethers.getSigners();

  // Construct a contract instance
  const contractFactory = await hre.ethers.getContractFactory("Swisstronik");
  const contract = contractFactory.attach(contractAddress);

  // Send a shielded transaction to set a message in the contract
  const setMessageTx = await sendShieldedTransaction(signer, contractAddress, contract.interface.encodeFunctionData("setMessage", ["Hello Swisstronik!!"]), 0);
  await setMessageTx.wait();

  //It should return a TransactionResponse object
  console.log("Transaction Receipt: ", setMessageTx);
}
```

* Add this by hardhat default

```
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

{% hint style="success" %}
The final `setMessage.js` script should look like this:
{% endhint %}

```
const hre = require("hardhat");
const { encryptDataField, decryptNodeResponse } = require("@swisstronik/swisstronik.js");

const sendShieldedTransaction = async (signer, destination, data, value) => {
  const rpclink = hre.network.config.url;
  const [encryptedData] = await encryptDataField(rpclink, data);
  return await signer.sendTransaction({
    from: signer.address,
    to: destination,
    data: encryptedData,
    value,
  });
};

async function main() {
  const contractAddress = "0xf84Df872D385997aBc28E3f07A2E3cd707c9698a";
  const [signer] = await hre.ethers.getSigners();
  const contractFactory = await hre.ethers.getContractFactory("Swisstronik");
  const contract = contractFactory.attach(contractAddress);
  const functionName = "setMessage";
  const messageToSet = "Hello Swisstronik!!";
  const setMessageTx = await sendShieldedTransaction(signer, contractAddress, contract.interface.encodeFunctionData(functionName, [messageToSet]), 0);
  await setMessageTx.wait();
  console.log("Transaction Receipt: ", setMessageTx);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

3. Execute the following command in your terminal to run the script using the Swisstronik network

   `npx hardhat run scripts/setMessage.js --network swisstronik`
4. Upon successful execution, your terminal should display `Transaction Receipt: TransactionResponse {...}` , now it's time to retrieve this message🎉


# Interact with the contract-Call

{% hint style="warning" %}
Make sure you have installed SwisstronikJS by running `npm i @swisstronik/swisstronik.js`
{% endhint %}

1. Within the scripts folder, create a file called `getMessage.js`

<figure><img src="/files/PJiAykglwLIASOhAIVt7" alt=""><figcaption></figcaption></figure>

2. Let's write our `getMessage.js` script

* Import hardhat and swisstronikJS functions

```
//Import hardhat and swisstronikJS functions
const hre = require("hardhat");
const { encryptDataField, decryptNodeResponse } = require("@swisstronik/swisstronik.js");
```

* Let's use `sendShieldedQuery` to send a call/query to the blockchain

```
/**
 * Send a shielded query/call to the Swisstronik blockchain.
 *
 * @param {object} provider - The provider object for making the call.
 * @param {string} destination - The address of the contract to call.
 * @param {string} data - Encoded data for the function call.
 *
 * @returns {Uint8Array} - Encrypted response from the blockchain.
 */
const sendShieldedQuery = async (provider, destination, data) => {
  // Get the RPC link from the network configuration
  const rpclink = hre.network.config.url;

  // Encrypt the call data using the SwisstronikJS function encryptDataField()
  const [encryptedData, usedEncryptedKey] = await encryptDataField(rpclink, data);

  // Execute the call/query using the provider
  const response = await provider.call({
    to: destination,
    data: encryptedData,
  });

  // Decrypt the call result using SwisstronikJS function decryptNodeResponse()
  return await decryptNodeResponse(rpclink, response, usedEncryptedKey);
};
```

* Write the `main` script to use `sendShieldedQuery` function

```
async function main() {
  // Address of the deployed contract
  const contractAddress = "0xf84Df872D385997aBc28E3f07A2E3cd707c9698a";

  // Get the signer (your account)
  const [signer] = await hre.ethers.getSigners();

  // Construct a contract instance (must match the name of contract)
  const contractFactory = await hre.ethers.getContractFactory("Swisstronik");
  const contract = contractFactory.attach(contractAddress);

  // Send a shielded query to retrieve data from the contract
  const functionName = "getMessage";
  const responseMessage = await sendShieldedQuery(signer.provider, contractAddress, contract.interface.encodeFunctionData(functionName));

  // Decode the Uint8Array response into a readable string
  console.log("Decoded response:", contract.interface.decodeFunctionResult(functionName, responseMessage)[0]);
}
```

* Add this by hardhat default

```
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

{% hint style="success" %}
The final `getMessage.js` script should look like this:
{% endhint %}

```
const hre = require("hardhat");
const { encryptDataField, decryptNodeResponse } = require("@swisstronik/swisstronik.js");

const sendShieldedQuery = async (provider, destination, data) => {
  const rpclink = hre.network.config.url;
  const [encryptedData, usedEncryptedKey] = await encryptDataField(rpclink, data);
  const response = await provider.call({
    to: destination,
    data: encryptedData,
  });
  return await decryptNodeResponse(rpclink, response, usedEncryptedKey);
};

async function main() {
  const contractAddress = "0xf84Df872D385997aBc28E3f07A2E3cd707c9698a";
  const [signer] = await hre.ethers.getSigners();
  const contractFactory = await hre.ethers.getContractFactory("Swisstronik");
  const contract = contractFactory.attach(contractAddress);
  const functionName = "getMessage";
  const responseMessage = await sendShieldedQuery(signer.provider, contractAddress, contract.interface.encodeFunctionData(functionName));
  console.log("Decoded response:", contract.interface.decodeFunctionResult(functionName, responseMessage)[0]);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

```

3. Execute the following command in your terminal to run the script using the Swisstronik network

```
npx hardhat run scripts/getMessage.js --network swisstronik
```

4. Upon successful execution, your terminal should display `Decoded response: Hello Swisstronik!!` or the latest message you've defined in the contract 🎉


# Crafts and Mint Token ERC20

Task Details: Craft an ERC20 contract that mints at least 100 tokens with Hardhat (in 7 Steps)

{% hint style="warning" %}
Make sure you have installed SwisstronikJS by running `npm i @swisstronik/swisstronik.js`
{% endhint %}

1. Within the scripts folder, create a file called `deploy.js and mint.js`

<figure><img src="/files/PJiAykglwLIASOhAIVt7" alt=""><figcaption></figcaption></figure>

2. Let's write our `deploy.js` script

```
// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const hre = require("hardhat");

async function main() {
  const contract = await hre.ethers.deployContract("TestToken");

  await contract.waitForDeployment();

  console.log(`deployed to ${contract.target}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

3. And then let's write our `mint.js` script

```
// Import necessary modules from Hardhat and SwisstronikJS
const hre = require("hardhat");
const { encryptDataField, decryptNodeResponse } = require("@swisstronik/swisstronik.js");

// Function to send a shielded transaction using the provided signer, destination, data, and value
const sendShieldedTransaction = async (signer, destination, data, value) => {
  // Get the RPC link from the network configuration
  const rpcLink = hre.network.config.url;

  // Encrypt transaction data
  const [encryptedData] = await encryptDataField(rpcLink, data);

  // Construct and sign transaction with encrypted data
  return await signer.sendTransaction({
    from: signer.address,
    to: destination,
    data: encryptedData,
    value,
  });
};

async function main() {
  // Address of the deployed contract
  const contractAddress = "0x649f418470A681ddd505d6537f61Da58b58B7FD0";

  // Get the signer (your account)
  const [signer] = await hre.ethers.getSigners();

  // Create a contract instance
  const contractFactory = await hre.ethers.getContractFactory("TestToken");
  const contract = contractFactory.attach(contractAddress);

  // Send a shielded transaction to mint 100 tokens in the contract
  const functionName = "mint100tokens";
  const mint100TokensTx = await sendShieldedTransaction(signer, contractAddress, contract.interface.encodeFunctionData(functionName), 0);

  await mint100TokensTx.wait();

  // It should return a TransactionReceipt object
  // console.log("Transaction Receipt: ", mint100TokensTx);
}

// Using async/await pattern to handle errors properly
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

4. Execute the following command in your terminal to run the deploy script using the Swisstronik network

```
npx hardhat run scripts/deploy.js --network swisstronik
```

5. Execute the following command in your terminal to run the mint script using the Swisstronik network

```
npx hardhat run scripts/mint.js --network swisstronik
```

6. Upon successful execution, your terminal should display the latest message you've defined in the contract 🎉


# PERC20 (Private ERC20) Deploy, Mint and Transfer.

Task Details: Craft an ERC20 contract that mints at least 100 tokens with Hardhat (in 7 Steps)

{% hint style="warning" %}
Make sure you have installed SwisstronikJS by running `npm i @swisstronik/swisstronik.js`
{% endhint %}

1. Make an .env file for store your PK (Private Key) to access your wallet.
2. Ensure you have enough funds token to doing the task.
3. Make 3 file (deploy.js, mint.js and transfer.js) inside the script folder&#x20;
4. Open the `deploy.js` file and write our script

```
const { ethers } = require("hardhat");

async function main() {
  const perc20 = await ethers.deployContract("PERC20Sample");
  await perc20.deployed();

  console.log(`PERC20 was deployed to ${perc20.address}`);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

5. And then let's write our `mint.js` script

```
// Import necessary modules from Hardhat and SwisstronikJS
const hre = require("hardhat");
const {
  encryptDataField,
  decryptNodeResponse,
} = require("@swisstronik/swisstronik.js");

// Function to send a shielded transaction using the provided signer, destination, data, and value
const sendShieldedTransaction = async (signer, destination, data, value) => {
  // Get the RPC link from the network configuration
  const rpcLink = hre.network.config.url;

  // Encrypt transaction data
  const [encryptedData] = await encryptDataField(rpcLink, data);

  // Construct and sign transaction with encrypted data
  return await signer.sendTransaction({
    from: signer.address,
    to: destination,
    data: encryptedData,
    value,
  });
};

async function main() {
  // Address of the deployed contract
  const contractAddress = "0x2eEa4a8A9B7D8FE2b9d3A6e0e08708046d6bacfb";

  // Get the signer (your account)
  const [signer] = await hre.ethers.getSigners();

  // Create a contract instance
  const contractFactory = await hre.ethers.getContractFactory("PERC20Sample");
  const contract = contractFactory.attach(contractAddress);

  // Send a shielded transaction to mint 100 tokens in the contract
  const functionName = "mint";
  const mintToken = await sendShieldedTransaction(
    signer,
    contractAddress,
    contract.interface.encodeFunctionData(functionName),
    0
  );

  await mintToken.wait();

  // It should return a TransactionReceipt object
  console.log("Mint Transaction Hash: ", mintToken.hash);
}

// Using async/await pattern to handle errors properly
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

6. And the last write our `transfer.js` script

```
// Import necessary modules from Hardhat and SwisstronikJS
const hre = require("hardhat");
const {
  encryptDataField,
  decryptNodeResponse,
} = require("@swisstronik/swisstronik.js");

// Function to send a shielded transaction using the provided signer, destination, data, and value
const sendShieldedTransaction = async (signer, destination, data, value) => {
  // Get the RPC link from the network configuration
  const rpcLink = hre.network.config.url;

  // Encrypt transaction data
  const [encryptedData] = await encryptDataField(rpcLink, data);

  // Construct and sign transaction with encrypted data
  return await signer.sendTransaction({
    from: signer.address,
    to: destination,
    data: encryptedData,
    value,
  });
};

async function main() {
  // your deployed contract
  const replace_contractAddress = "0x2eEa4a8A9B7D8FE2b9d3A6e0e08708046d6bacfb";

  const [signer] = await hre.ethers.getSigners();

  const replace_contractFactory = await hre.ethers.getContractFactory(
    "PERC20Sample"
  );
  const contract = replace_contractFactory.attach(replace_contractAddress);

  const replace_functionName = "transfer";
  const replace_functionArgs = ["0x16af037878a6cAce2Ea29d39A3757aC2F6F7aac1","1",];
  const transaction = await sendShieldedTransaction(
    signer,
    replace_contractAddress,
    contract.interface.encodeFunctionData(
      replace_functionName,
      replace_functionArgs
    ),
    0
  );

  await transaction.wait();

  console.log("Transfer Transaction Hash: ", transaction.hash);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

4. Don't forget to compile the contract

```
npm run compile
```

5. Execute the following command in your terminal to run the deploy script using the Swisstronik network

```
npm run deploy
```

6. Execute the following command in your terminal to run the mint script using the Swisstronik network

```
npm run mint
```

7. Execute the following command in your terminal to run the transfer script using the Swisstronik network

```
npm run transfer
```

Upon successful execution, your terminal should display the latest message you've defined in the contract 🎉


# JSON RPC Call using ETH getStorage

Task Details : Make a JSON RPC call using eth\_getStorageAt() to get the first storage variable (slot #0) of any deployed smart contract

1. Within the scripts folder, create a file called `getStorage.js`
2. Let's write our `getStorage.js` script

```
const hre = require("hardhat");
const { ethers } = require("ethers");

const getStorageValue = async (rpcURL, contractAddress, slotNumber) => {
  const provider = new ethers.getDefaultProvider(rpcURL); // initial ether rpc

  try {
    const storageValue = await provider.getStorage(contractAddress, slotNumber);
    console.log(`\nResponse:`);
    console.log(`Storage Value at Slot ${slotNumber}: 0x${storageValue}`);
  } catch (error) {
    console.error("Error:", error);
  }
};

async function main() {
  const contractAddress = "0xf84Df872D385997aBc28E3f07A2E3cd707c9698a"; // contract address
  const slotNumber = 0; // slot number
  const rpcURL = hre.network.config.url; // get rpc from hardhat.config.js

  let printLogs = {
    contract: contractAddress,
    slotNumber: slotNumber,
    rpcURL: rpcURL,
  };

  console.log(printLogs);

  await getStorageValue(rpcURL, contractAddress, slotNumber);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
```

3. Execute the following command in your terminal to run the getStorage script using the Swisstronik network

```
npx hardhat run scripts/getStorage.js --network swisstronik
```

4. Execute the following command in your terminal to run the getStorage script using the ETH Sepolia network

```
npx hardhat run scripts/getStorage.js --network sepolia
```

5. Execute the following command in your terminal to run the getStorage script using the Polygon Mumbai network

```
npx hardhat run scripts/getStorage.js --network mumbai
```

6. Upon successful execution, your terminal should display the latest message you've defined in the contract 🎉

<figure><img src="/files/jhxXZvbJHvu7klIRp9HD" alt=""><figcaption><p><em>The output should like this</em> </p></figcaption></figure>

***

`01. Provide an explanation of the value retrieved from the RPC call.`\
\
✅ Swisstronik Network:\
✔ Value: 0xc73e7f645a2bf1365a0903afa03a2cb5029ba989df7844b0fe7751b1ba918ea4\
✔ Explanation: This hexadecimal string represents the raw data stored in the contract's first storage slot, which corresponds to the private message variable. The value 0xc73e7f645a2bf1365a0903afa03a2cb5029ba989df7844b0fe7751b1ba918ea4 encodes the current message stored in the contract. This value can change when someone calls the setMessage() function to update the message.\
\
✅ Mumbai Network and Sepolia Network:\
✔ Value: 0x0000000000000000000000000000000000000000000000000000000000000000\
✔ Explanation: These values are also hexadecimal strings, but they consist entirely of zeros. This suggests that either no meaningful data was stored in the first storage slot of the contract on these networks. Essentially, it indicates that there is no message stored in the contract on these networks, or the message is an empty string.\
\
`02. What does this retrieved value represent? Is there any difference if this RPC call is made on the Sepolia or Mumbai networks?`\
\
✅ Swisstronik Network, you are seeing the encoded or hashed representation of the current message stored in the contract's first storage slot.\
✅ Mumbai and Sepolia Networks, you are seeing all zeros in the first storage slot, indicating an empty message or no message has been set on these networks for the given contract.