The current estimated reward rate of Aleo is 31.11%. This means that, on average, stakers of Aleo are earning about 31.11% if they hold an asset for 365 days. 24 hours ago the reward rate for Aleo was 29.30%. 30 days ago, the reward rate for Aleo was 19.68%. Today, the staking ratio, or the percentage of eligible tokens currently being staked, is 507.16%. In other words, there are 545.5M of Aleo staked, which means that Aleo has a staking market cap of CA$1.1B. This is compared to a total asset market cap of CA$215.4M.

What is Native Staking

Native staking is the process of locking up (or "staking") a blockchain's native cryptocurrency to support its network operations, such as transaction validation, network security, and governance. In return for staking, participants (often called "delegators" or "validators") receive rewards, typically in the form of the same cryptocurrency they have staked.

One can participate in the consensus of the Aleo network by Native Staking or by liquid staking. In this technical article we will be discussing how to stake natively on the Aleo network. Below are the key aspects involved in staking natively on the Aleo network.

1. Native Cryptocurrency: To participate in Native staking specifically involves the Aleo blockchain’s native token ($ALEO). This token is used within the network for staking and rewards.
2. Proof of Stake (PoS) Consensus: Native staking is fundamental to Proof of Stake (PoS) or its variations. The network delegators are responsible for helping validate blocks, which is a central feature of PoS networks. To protect the integrity of the Aleo blockchain, the PoS consensus is adopted.
3. Rewards and Incentives: Delegators who participates in the native staking often receive rewards in proportion to their staked amount. This can come in the form of newly minted tokens, providing an incentive to participate in network security.
4. Security and Governance: By participating in Native staking, delegators helps protect the Aleo network from attacks. Delegators in the network also have governance rights, allowing them to vote on changes to network protocols.

Benefits and Risks:

• Benefits: Stakers earn passive income and contribute to network security. It’s less resource-intensive compared to Proof of Work (PoW).
• Risks: Staked assets may be locked, reducing liquidity. If validators behave maliciously, they may lose part of their staked funds (a penalty known as "slashing").

Steps to Native stake your Aleo token

At the moment there is no available way to easily participate in native staking through interacting with a simple UI design. The only available way to participate in native staking on the Aleo network is through the Command Line Interface (CLI).

1. Requirement

to stake natively on the Aleo natework, you would need a minimum of 10, 000 Aleo credits.

2. Choosing a Validator: A delegator would needto choose which validator to delegate tokens to. At the moment there are 16 Aleo validators and 188 delegators. Here are the list of validators. When selecting a validator, consider the following:

• Performance. High uptime and reliable performance are crucial.
• Contributions. Validators that contribute to the ecosystem through tools, communities, or public RPC endpoints.
• Commissions. Reasonable commission rates for sustainable operations.
• Decentralization. Avoid validators with overly concentrated stake to maintain network resilience.
• Reputation. Track record in other ecosystems can indicate future performance on Aleo.

3. Guide
Since there is no UI for easily staking in Aleo, we will be using the Leo CLI to complete this process. Below is the guide to set up and stake natively on the Aleo network.

Install Leo and other dependences
First, we need to get the

— Follow the guide here to install Leo and other dependables here

— On you CLI run leo --version to confirm your Leo CLI version

Bonding

— To bond to a validator run:

leo execute --program credits.aleo --network mainnet --endpoint https://node.puzzle.online --private-key {PRIVATE_KEY} -b bond_public {VALIDATOR_ADDRESS} {WITHDRAWAL_ADDRESS} {AMOUNT}

PRIVATE_KEY is the private key of the account that has the funds

VALIDATOR_ADDRESS is the address of the validator you want to bond to

WITHDRAWAL_ADDRESS is the address of the account you want to use that the credits will be sent to when you decide to unbond this can be the same as the account that currently has the ALEO, but you may want to separate out for security

endpoint are the specific digital location where requests or API calls for information are sent by the delegator program to retrieve the digital resource that exist in the validator. Here, we used the puzzle wallet wnd point.

AMOUNT is the amount (in microcredits) of ALEO you want to stake — for example: 1 ALEO is 1000000u64 10,000 ALEO is 10000000000u64

— so if you wanted to bond 11,111 ALEO, you would have something like

leo execute --program credits.aleo --network mainnet --endpoint https://node.puzzle.online --private-key {PRIVATE_KEY} -b bond_public {VALIDATOR_ADDRESS} {WITHDRAWAL_ADDRESS} 11111000000u64

The leo cli will then show you the fee breakdown of the transaction and ask you to confirm the execution (to confirm, just enter y)

— Then go to aleoscan , input your wallet address and search, check the "Lifetime stake reward" field on aleoscan to see how much you have accrued as staking reward.

Unstaking

Unstaking is a two-step process. First delegators must initiate unstaking of any desired amount. Then, after a certain processing period, they are able to claim their unbonded token, transferring them back to their public balance. This lock-up period is specified by the network's protocol, 360 blocks (about 3 hours), to ensure stability. You can check out the remaining time by visiting the Unstake tab anytime.These conditions are designed to prevent sudden changes in the network's stake distribution that could affect its operation and security.

• The first step involves unbonding the staked token
• The second step involves withdrawing the unstaked tokens into the withdrawal wallet address

Unbonding

This involves unbonding or unstaking the token from the validator delegation.

leo execute unbond_public {WITHDRAWAL_ADDRESS} {Amount} --program credits.aleo --network mainnet --endpoint https://node.puzzle.online --private-key {WITHDRAWAL_PRIVATE_KEY} --broadcast

Withdrawal

After the unbonding transaction is confirmed, you must wait the 360 blocks (about 3 hours) lock-up period protecting the network. Next, we transfer the credits to the withdrawal address.

leo execute claim_unbond_public {WITHDRAWAL_ADDRESS} --program credits.aleo --network mainnet --endpoint https://node.puzzle.online --private-key {WITHDRAWAL_PRIVATE_KEY} --broadcast

Press y and proceed with the transaction. Here,

WITHDRAWAL_ADDRESS this should be the wallet you assigned as your withdrawal wallet during your bonding stage.

WITHDRAWAL_PRIVATE_KEY This is the private key to the withdrawal wallet.

This will withdraw the amount into your account. You have finally been able to participate in native staking on the Aleo network.

In this article, I’ll provide a step-by-step guide on how to securely liquid-stake Aleo. Aleo is a layer 1 blockchain that uses zero knowledge proofs to power private applications.

The crucial tasks in the aleo network are the

Provers

The provers in the aleo network create the cryptographic proof of transaction without revealing the meta data associated with the transaction.

2. Validators

To secure the Aleo consensus, the validators form consensus on new blocks and block history. The validators need to stake Aleo native token to become actve. The minimum stake to become a validator in the Aleo network is 10,000,000 Aleo credits. Validators can also receive stake from other token holders in the form of delegations.

3. Delegators

There are the person or institutions who would love to participate in keeping the protocol secure, however, they do not wish to run your own validator or could not meet up with the high credit requirement to become a validator. They can opt to become a delegator by delegating their Aleo credit to another validator. Delegating is non-custodial, meaning you retain full control of your funds. As a delegator you earn some Aleo staking rewards. There are two types of delegation in Aleo

Liquid staking and Ntive staking; Native staking locks tokens directly in a blockchain network, making them temporarily inaccessible, while liquid staking allows users to stake tokens while receiving tradable "liquid" tokens that represent their staked assets, maintaining flexibility and liquidity.

3a. Liquid Staking

To start staking for the first time as a first-time staker, you must stake at least 10 Aleo. However, if you are staking again to add to your stake (returning staker), you can stake a minimum of 1 Aleo. In liquid staking, the liquid stake provider (pondo) takes some percentage of reward for providing the staking services. Staking rewards are earned every block and are directly added to your staking balance, compounding your rewards.

3b. Native Staking

To stake natively on the Aleo network as a delegator, you need a minimum of 10000 Aleo. Also, Staking rewards are earned every block and are directly added to your staking balance, compounding your rewards. With native stking, you will need to choose the validator to stake with.

We will be taking about Liquid Staking on the Aleo networking using the the staking.xyz UI interface.

How to stake - Liquid Staking

Setting up Puzzle wallet

• Install Puzzle wallet’s browser extension from https://chromewebstore.google.com/detail/puzzle-aleo-wallet/fdchdcpieegfofnofhgdombfckhbcokj. Please note that Puzzle wallet is supported on Chrome or Brave browsers.

• Select whether you would like to create a new wallet or import an existing wallet.

• Set a password to use to unlock your wallet.

• After creating your wallet, please visit the Seed phrase section under Settings and write down your 12 word seed phrase. Safeguard this phrase as it will be the only way to regain access to your wallet if you ever lose access.

Step-by-step guide to staking on Staking.xyz:

2) Visit Staking.xyz to start managing your staking. Connect your wallet. At the moment the Puzzle wallet, Avail wallet and the Leo wallet are available options to use. Also, ensure you have your Aleo in this wallet.

2) Select Validator and Amount. First, Navigate to the liquid staking and input the amount of ALEO you want to stake. Next, you click stake to stake the quantity of Aleo you want. From the validator list choose a validator of your choice, and click on the select validator button.

You get a pop out, that require that you sign with your wallet. Click on the proceed in the wallet key

Your wallet would require you accept the transaction. Accept and si

Wait for the transaction to complete

Liquid staking done. You can click wiew activity to show your transaction detail and rewards.

You get a pAleo token equivalent to the quantity of Aleo you staked.

you need to wait for 1 hour before transferring your ALEO.

Begin unstaking using Staking.xyz

• Visit the Unstake tab and connect your wallet.
• The unstaking takes an approximately 3 days to complete
• Input the amount you want to unstake. Check out the details of your unstaking transaction. If everything looks good, proceed by clicking on the “Unstake” button and signing the transaction.

• Once unstaking is complete, you will need to withdraw your unstaked Aleo Credits. After withdrawing, you can begin transferring your Aleo Credits.

Important considerations for staking:

• Delegators:
• Need a minimum of 10,000 Aleo Credits to start earning rewards.
• Rewards are earned after 1–2 blocks and compound automatically.
• Validators:
• Must have at least 10,000,000 Aleo Credits staked to be active.
• Cannot exit the active set if they have any active delegators.

Staking rewards and protocols:

• Rewards:
• Protocol issues 5% of the starting total supply as staking rewards.
• Coinbase rewards are distributed to Aleo stakers, with a third going to include solutions provided by Aleo provers.
• ARC Proposals:
• ARC-0037: Allows separate worker and withdrawal addresses.

ARC-0038: Validators can collect commissions from delegators.

ARC-0041: Enables validators to activate without directly owning 10 million Aleo Credits.

Staking on Aleo involves careful consideration and due diligence. Always research validators and understand the staking mechanics before committing your ALEO. Stay updated with the latest developments as Aleo moves closer to its mainnet launch.

By following this guide, you can effectively participate in the staking process on Staking.xyz, contributing to the network’s security and earning rewards in the process.

Stake with Our Validator

Moniker:

Nodeint

Account Address:

init13v87veezdsuzp7g3w0wxw0xt3u97ayscnfndst

Operator_address:

initvaloper13v87veezdsuzp7g3w0wxw0xt3u97aysc8v257m

Project Information

Back to content

Official Information:

• Official site
• Blog
• Discord
• Github

DESCRIPTION

Initia is a pioneering network for interwoven rollups, revolutionizing blockchain by simplifying complexity and providing a unified platform akin to using your favorite smartphone, inspired by Apple's design philosophy.

Server Requirements

Back to content

- Memory: 16 GB RAM
- CPU: 4 cores
- Disk: 1 TB SSD
- Bandwidth: 1 Gbps
- Linux amd64 arm64 (Ubuntu LTS release)

Installation guide

1. Install required packages

sudo apt update && \
sudo apt install curl git jq build-essential gcc unzip wget lz4 -y

2. Install Go

cd $HOME && \
ver="1.22.0" && \
wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz" && \
sudo rm -rf /usr/local/go && \
sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz" && \
rm "go$ver.linux-amd64.tar.gz" && \
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.bash_profile && \
source $HOME/.bash_profile && \
go version

3. Install initia binary

git clone https://github.com/initia-labs/initia.git
cd initia
git checkout v0.2.15
make install
initiad version

4. Set up variables

replace "My_Node" with the name you would wish to call your node

# Customize if you need
echo 'export MONIKER="NodeInt"' >> ~/.bash_profile
echo 'export CHAIN_ID="initiation-1"' >> ~/.bash_profile
echo 'export WALLET_NAME="wallet"' >> ~/.bash_profile
echo 'export RPC_PORT="26657"' >> ~/.bash_profile
source $HOME/.bash_profile

5. Initialize the node

cd $HOME
initiad init $MONIKER --chain-id $CHAIN_ID
initiad config set client chain-id $CHAIN_ID
initiad config set client node tcp://localhost:$RPC_PORT
initiad config set client keyring-backend os # You can set it to "test" so you will not be asked for a password

6. Download genesis.json

wget https://initia.s3.ap-southeast-1.amazonaws.com/initiation-1/genesis.json -O $HOME/.initia/config/genesis.json

7. Add Peers to the config.toml

# Endpoint URL
URL="https://initia-rpc.stake2earn.com/net_info" 

# Fetch data from the endpoint 
response=$(curl -s $URL) 

# Parse JSON and construct PEERS string using jq  
PEERS=$(echo $response | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):" + (.node_info.listen_addr | capture("(?<ip>.+):(?<port>[0-9]+)$").port)' | paste -sd "," -) 

# Display the PEERS string 
echo "PEERS=\"$PEERS\"" 

# Set the peers 
sed -i 's|^persistent_peers *=.*|persistent_peers = "'$PEERS'"|' $HOME/.initia/config/config.toml

Configuration set up

sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.initia/config/config.toml
sed -i -e "s/^log_level *=.*/log_level = \"main:info,state:info,statesync:info,*:error\"/" $HOME/.initia/config/config.toml
sed -i -e "s/^max_num_inbound_peers *=.*/max_num_inbound_peers = 300/" $HOME/.initia/config/config.toml
sed -i -e "s/^max_num_outbound_peers *=.*/max_num_outbound_peers = 300/" $HOME/.initia/config/config.toml

8. Change ports (Optional)

# Customize if you need
EXTERNAL_IP=$(wget -qO- eth0.me) \
PROXY_APP_PORT=26658 \
P2P_PORT=26656 \
PPROF_PORT=6060 \
API_PORT=1317 \
GRPC_PORT=9090 \
GRPC_WEB_PORT=9091

sed -i \
    -e "s/\(proxy_app = \"tcp:\/\/\)\([^:]*\):\([0-9]*\).*/\1\2:$PROXY_APP_PORT\"/" \
    -e "s/\(laddr = \"tcp:\/\/\)\([^:]*\):\([0-9]*\).*/\1\2:$RPC_PORT\"/" \
    -e "s/\(pprof_laddr = \"\)\([^:]*\):\([0-9]*\).*/\1localhost:$PPROF_PORT\"/" \
    -e "/\[p2p\]/,/^\[/{s/\(laddr = \"tcp:\/\/\)\([^:]*\):\([0-9]*\).*/\1\2:$P2P_PORT\"/}" \
    -e "/\[p2p\]/,/^\[/{s/\(external_address = \"\)\([^:]*\):\([0-9]*\).*/\1${EXTERNAL_IP}:$P2P_PORT\"/; t; s/\(external_address = \"\).*/\1${EXTERNAL_IP}:$P2P_PORT\"/}" \
    $HOME/.initia/config/config.toml

sed -i \
    -e "/\[api\]/,/^\[/{s/\(address = \"tcp:\/\/\)\([^:]*\):\([0-9]*\)\(\".*\)/\1\2:$API_PORT\4/}" \
    -e "/\[grpc\]/,/^\[/{s/\(address = \"\)\([^:]*\):\([0-9]*\)\(\".*\)/\1\2:$GRPC_PORT\4/}" \
    -e "/\[grpc-web\]/,/^\[/{s/\(address = \"\)\([^:]*\):\([0-9]*\)\(\".*\)/\1\2:$GRPC_WEB_PORT\4/}" \
    $HOME/.initia/config/app.toml

9. Configure prunning to save storage (Optional)

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

10. Set min gas price

sed -i -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.15uinit,0.01uusdc\"/" $HOME/.initia/config/app.toml

11. Enable indexer (Optional)

sed -i "s/^indexer *=.*/indexer = \"kv\"/" $HOME/.initia/config/config.toml

12. Create a service file

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

[Service]
User=$USER
Type=simple
ExecStart=$(which initiad) start --home $HOME/.initia
Restart=on-failure
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

13. Start the node

Run tmux to open a virtual space

tmux

Then start the daemon to run the node

sudo systemctl daemon-reload && \
sudo systemctl enable initiad && \
sudo systemctl restart initiad && \
sudo journalctl -u initiad -f -o cat

14. Get your public RPC end point on your validator node

In another window run this

Fetch your IP and RPC port (It will print your RPC url)

RPC="http://$(wget -qO- eth0.me)$(grep -A 3 "\[rpc\]" $HOME/.initia/config/config.toml | egrep -o ":[0-9]+")" && echo $RPC

Check if it's responding

curl $RPC/status

If you are getting Connection refused , you need to make it accessible to the Internet:

Edit config

sed -i '/\[rpc\]/,/\[/{s/^laddr = "tcp:\/\/127\.0\.0\.1:/laddr = "tcp:\/\/0.0.0.0:/}' $HOME/.initia/config/config.toml

Restart your node

sudo systemctl restart initiad

Ensure logs are good

sudo journalctl -u initiad -f -o cat --no-hostname

Check if RPC is responding once again

curl $RPC/status

To Output your PUBLIC RPC URL again

echo $RPC

You can also paste this URL into your browser and ensure it works :) ---

If you are still getting Connection refused and you have ufw firewall you need to open it

Fetch RPC port. Make sure output is not empty

PORT=$(grep -A 3 "\[rpc\]" $HOME/.initia/config/config.toml | egrep -o ":[0-9]+") && \
PORT=${PORT#:} && \
echo $PORT

Add the rule

sudo ufw allow $PORT

Reload ufw

sudo ufw reload

15. Ensuring Faster syncing

press ctrl + c to stop the process then do the following

Download latest snapshot and update your peers

wget -O initia_latest.tar.lz4 https://storage.crouton.digital/testnet/initia/snapshots/initia_latest.tar.lz4
sudo systemctl stop initiad
cp $HOME/.initia/data/priv_validator_state.json $HOME/.initia/priv_validator_state.json.backup
initiad tendermint unsafe-reset-all --home $HOME/.initia --keep-addr-book
lz4 -c -d initia_202803.tar.lz4  | tar -x -C $HOME/.initia
mv $HOME/.initia/priv_validator_state.json.backup $HOME/.initia/data/priv_validator_state.json
sudo systemctl restart initiad && sudo journalctl -u initiad -f -o cat 

Update your peers

PEERS=$(curl -s --max-time 3 --retry 2 --retry-connrefused "https://rpc-initia-testnet.trusted-point.com/peers.txt")
if [ -z "$PEERS" ]; then
    echo "No peers were retrieved from the URL."
else
    echo -e "\nPEERS: "$PEERS""
    sed -i "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" "$HOME/.initia/config/config.toml"
    echo -e "\nConfiguration file updated successfully.\n"
fi

Stop the node

sudo systemctl stop initiad

Backup priv_validator_state.json

cp $HOME/.initia/data/priv_validator_state.json $HOME/.initia/priv_validator_state.json.backup

Reset DB

initiad tendermint unsafe-reset-all --home $HOME/.initia --keep-addr-book

Extract files fromt the arvhive

lz4 -d -c ./latest_snapshot.tar.lz4 | tar -xf - -C $HOME/.initia

Move priv_validator_state.json back

mv $HOME/.initia/priv_validator_state.json.backup $HOME/.initia/data/priv_validator_state.json

Restart the node

sudo systemctl restart initiad && sudo journalctl -u initiad -f -o cat

Check the synchronization status

Do this on another window

initiad status | jq -r .sync_info

16. Run the Oracle

Clone the slinky repository, change into the directory and get the latest version

git clone https://github.com/skip-mev/slinky.git && cd slinky && git checkout v0.4.4 

Build out the slinky

make build

Move the slinky folder

mv build/slinky /usr/local/bin/ 

sed -i '/^\[oracle\]/,/^$/ s/^enabled = ".*"/enabled = "true"/' 
$HOME/.initia/config/app.toml 

sed -i 's|^oracle_address = ".*"|oracle_address = "0.0.0.0:8080"|g' 
$HOME/.initia/config/app.toml

c

sed -i 's/^client_timeout = ".*"/client_timeout = "500ms"/' 
$HOME/.initia/config/app.toml

sed -i 's/^metrics_enabled = ".*"/metrics_enabled = "true"/' 
$HOME/.initia/config/app.toml

Enable the service file

sudo tee /etc/systemd/system/oracle.service > /dev/null <<EOF 
cd [Unit] 
Description=Initia Oracle 
After=network.target [Service] 
User=$USER 
Type=simple 
ExecStart=$(which slinky) --oracle-config-path 
root/slinky/config/core/oracle.json 
Restart=on-failure
LimitNOFILE=65535 
[Install] 
WantedBy=multi-user.target 
EOF 

Restart the oracle

sudo systemctl daemon-reload 
sudo systemctl enable oracle.service 
sudo systemctl restart oracle.service 
sudo journalctl -u oracle.service -o cat -f

Wallet

Create a wallet

initiad keys add $WALLET_NAME

Ensure to save your wallet informations like address, passphrase, public key.

Next, you will need some init token to set up a validator.

Go to the FAUCET site, copy and paste your wallet address and click submit.

To restore your keys you have created, do this

initiad keys add $WALLET_NAME --recover

Save wallet and validator address

WALLET_ADDRESS=$(initiad keys show $WALLET_NAME -a) 
VALOPER_ADDRESS=$(initiad keys show $WALLET_NAME --bech val -a) 
echo "export WALLET_ADDRESS="$WALLET_ADDRESS >> $HOME/.bash_profile 
echo "export VALOPER_ADDRESS="$VALOPER_ADDRESS >> $HOME/.bash_profile 
source $HOME/.bash_profile

Check sync status, once your node is fully synced, the output from above will print "false"

initiad status 2>&1 | jq 

After creating a validator, make sure the fund has been funded sucessfully

initiad query bank balances $WALLET_ADDRESS

Create a validator

Run the command below on a new window.

initiad tx mstaking create-validator \
  --amount=1000000uinit \
  --pubkey=$(initiad tendermint show-validator) \
  --moniker=$MONIKER \
  --chain-id=$CHAIN_ID \
  --commission-rate=0.05 \
  --commission-max-rate=0.10 \
  --commission-max-change-rate=0.01 \
  --from=$WALLET_NAME \
  --identity="" \
  --website="" \
  --details="Initia to the moon!" \
  --gas=2000000 --fees=300000uinit \
  -y

Get the content of the validator private key, ensure to save it in a safe place

cd $HOME/.initia/config/
cat priv_validator_key.json

Check your validator here but it takes some time be appear there

If you can't find your validator. you can check your validator directly on the api

initiad q mstaking validator $(initiad keys show $WALLET_NAME --bech val -a)cd 

Upgrading to the latest version

Only do this when a new version is announced and requires validators to upgrade

cd $HOME
rm -rf initia
git clone https://github.com/initia-labs/initia.git
cd initia
git checkout #version
make install

initiad version

sudo systemctl restart initiad

Useful commands

Check node status

initiad status | jq

Delegate 1 INIT to yourself (change <wallet_name>):

initiad tx mstaking delegate $(initiad keys show <wallet_name> --bech val -a) 1000000uinit --from <wallet_name> --chain-id initiation-1 --gas-adjustment 1.4 --gas=2000000 --fees=563000move/944f8dd8dc49f96c25fea9849f16436dcfa6d564eec802f3ef7f8b3ea85368ff -y

Delegate 1 INIT to another validator (change <valoper>):

initiad tx mstaking delegate <valoper> 1000000uinit --from <wallet_name> --chain-id initiation-1 --gas-adjustment 1.4 --gas=2000000 --fees=563000move/944f8dd8dc49f96c25fea9849f16436dcfa6d564eec802f3ef7f8b3ea85368ff -y

Check block Height

llocal_height=$(initiad status | jq -r .sync_info.latest_block_height); network_height=$(curl -s https://initia-testnet-rpc.polkachu.com/status | jq -r .result.sync_info.latest_block_height); blocks_left=$((network_height - local_height)); echo "Your node height: $local_height"; echo "Network height: $network_height"; echo "Blocks left: $blocks_left"

Edit validator information

initiad tx mstaking edit-validator --moniker="<NEW_MONIKER>" --from=wallet_name --gas=2000000 --fees=300000uinit -y

initiad tx mstaking edit-validator --website="<NEW_WEBSITE>" --from=$WALLET_NAME --gas=2000000 --fees=300000uinit --node https://initia-testnet-rpc.kzvn.xyz/ --chain-id initiation-1 -y

Query your validator

initiad q mstaking validator $(initiad keys show $WALLET_NAME --bech val -a) 

Query missed blocks counter & jail details of your validator

initiad q slashing signing-info $(initiad tendermint show-validator)

Unjail your validator

initiad tx slashing unjail --from $WALLET_NAME --gas=2000000 --fees=300000uinit -y

Delegate tokens to your validator

initiad tx mstaking delegate $(initiad keys show $WALLET_NAME --bech val -a)  <AMOUNT>uinit --from $WALLET_NAME --gas=2000000 --fees=300000uinit -y

Get your p2p peer address

initiad status | jq -r '"\(.NodeInfo.id)@\(.NodeInfo.listen_addr)"'

Edit your validator

initiad tx mstaking edit-validator --website="<WEBSITE>" --details="<DESCRIPTION>" --moniker="<NEW_MONIKER>" --from=$WALLET_NAME --gas=2000000 --fees=300000uinit -y

Send tokens between wallets

initiad tx bank send $WALLET_NAME <TO_WALLET> <AMOUNT>uinit --gas=2000000 --fees=300000uinit -y

Query your wallet balance

initiad q bank balances $WALLET_NAME

Monitor server load

sudo apt update
sudo apt install htop -y
htop

Query active validators

initiad q mstaking validators -o json --limit=1000 \
| jq '.validators[] | select(.status=="BOND_STATUS_BONDED")' \
| jq -r '.voting_power + " - " + .description.moniker' \
| sort -gr | nl

Query inactive validators

initiad q mstaking validators -o json --limit=1000 \
| jq '.validators[] | select(.status=="BOND_STATUS_UNBONDED")' \
| jq -r '.voting_power + " - " + .description.moniker' \
| sort -gr | nl

Check logs of the node

sudo journalctl -u initiad -f -o cat

Restart the node

sudo systemctl restart initiad

Stop the node

sudo systemctl stop initiad

Delete the node from the server

# !!! IF YOU HAVE CREATED A VALIDATOR, MAKE SURE TO BACKUP `priv_validator_key.json` file located in $HOME/.initia/config/ 
sudo systemctl stop initiad
sudo systemctl disable initiad
sudo rm /etc/systemd/system/initiad.service
rm -rf $HOME/.initia
sudo rm /usr/local/bin/initiad

Example gRPC usage

wget https://github.com/fullstorydev/grpcurl/releases/download/v1.7.0/grpcurl_1.7.0_linux_x86_64.tar.gz
tar -xvf grpcurl_1.7.0_linux_x86_64.tar.gz
chmod +x grpcurl
./grpcurl  -plaintext  localhost:$GRPC_PORT list
### MAKE SURE gRPC is enabled in app.toml
# grep -A 3 "\[grpc\]" $HOME/.initia/config/app.toml

Example REST API query

curl localhost:$API_PORT/cosmos/mstaking/v1beta1/validators
### MAKE SURE API is enabled in app.toml
# grep -A 3 "\[api\]" $HOME/.initia/config/app.toml

The Decentralized and Scaled network with a throughput of 10'000 tr/sec and 1000+ Nakamoto Coefficient.

Content

Project Information

Description

Server Requirements

What is being installed?

Launch

1. Preparation

2. Run your Massa Node

3. Create your Massa Wallet

4. Configuration

5. Faucet your wallet

6. Staking

7. Register your node

8. Update your Node

Congratulations

Extra

Community Contribution

Useful Links

Project Information

Back to content

Official Information:

• Official site
• Blog
• White paper
• live testnet at massa.net/testnet

Unofficial Information

• Massa adopted

DESCRIPTION

Current blockchains that scale to high transaction throughputs are either centralized or unsafe. Massa is designing a new architecture, called the Blockclique, that scales transaction throughput up to 10,000 transactions per second without sacrificing decentralization nor security. Massa's architecture is based on transaction sharding in a multithreaded block graph. Massa is a Proof-of-stake blockchain.

Server Requirements

Back to content

⠀Recommendations from the team (VPS/VDS/DS):
8 cores, 16 GB RAM, 1TB disk and a decent internet connection.

What is being installed?

Back to content

⠀ The project consists of several applications:

• Node - creates blocks, is launched by a service file for smooth operation;
• Client - allows you to interact with the wallet and the network using various commands. Runs when needed during a running node.

launch

Back to content

⠀ Each subsection is a separate type of installation, you need to choose one of them.

Back to content

Update packages

sudo  apt update &&  sudo  apt upgrade -y

Open your ports

sudo ufw allow 31244 && sudo ufw allow 31245 && sudo ufw allow 22

Enable your firewalls

sudo ufw enable && sudo ufw status

Install required packages

sudo apt install pkg-config curl git build-essential libssl-dev libclang-dev cmake

Install rustup and configure your path

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Follow the instruction and press 1 to install.

source $HOME/.cargo/env

Install nightly and set it as default

rustup default 1.74.1

rustup toolchain install 1.74.1 && rustup default 1.74.1

Check rust version

rustc --version

Clone the massa repo

git clone https://github.com/massalabs/massa.git

Back to content

Start the node:

cd massa/massa-node/ && tmux

Launch the node, on Ubuntu:

./massa-node -p <PASSWORD> |& tee logs.txt

RUST_BACKTRACE=full cargo run --release -- -p <PASSWORD> |& tee logs.txt

change <PASSWORD> with a password of your choosing
Your node should be up now, you can close the window

• Open Another Window

Start the client:

cd massa/massa-client/ && cargo run --release -- -p <PASSWORD>

Your client should be running now, you can close your client type.

Replace <PASSWORD> with your password
type ctrl + c to leave

Back to content

Still on the same window,

A. Start the Client

Start the interactive Client and load a wallet file:

cargo run --release — -p <PASSWORD>

replace <PASSWORD> with your password

Generate a new private key 🗝 and associated public key/ address; run the code below in the command prompt

wallet_generate_secret_key

OR

If you are using BearBy wallet:

log into you account

Click on the Setting icon below the page as show in image

click on security and Privacy

Export Private key

Impute your wallet password

Click on the export key

your private key gets revealed

Copy your private key

you can add manually an existing private key:

wallet_add_secret_keys <your_private_key>

B. View your Massa wallet details

The list of addresses and keys of your wallet can be accessed with:

wallet_info

C. Register your wallet private key to your node;

node_start_staking

node_start_staking <your_wallet_address>

You can always close your client with the command

CTRL + C

Back to content

Nodes in the Massa network need to establish connections between them to communicate, propagate blocks and operations, and maintain consensus and synchrony all together.

In Massa, nodes are non-routable by default and require a manual operation to be made routable. To do this you need to configure your node

cd && cd massa/massa-node/config

vim config.toml

then press i on your keyboard; this creates and input mode. Copy and paste this

[network]
routable_ip = "AAA.BBB.CCC.DDD"

replace AAA.BBB.CCC.DDD with your ip-address

After editing the config.toml file, press esc button on your keyboard, then type :wq to exit and save your changes.

Congratulations!!! you have just set up and registered your Massa Mainnet node

useful links

Back to content

Official site of the project | Official Telegram group

Telegram announcement channel |Twitter

Discord | reddit | GitHub |

Introduction

In this blog we will be demonstration the use of Leo transpiler using the Iris flower dataset.

The Iris dataset was used in R.A. Fisher's classic 1936 paper, The Use of Multiple Measurements in Taxonomic Problems, and can also be found on the UCI Machine Learning Repository.

It includes three iris species with 50 samples each as well as some properties about each flower. One flower species is linearly separable from the other two, but the other two are not linearly separable from each other.

The columns in this dataset are:

• Id
• SepalLengthCm
• SepalWidthCm
• PetalLengthCm
• PetalWidthCm
• Species

Python a programming language that is used greatly in the machine learning, AI and data science world, there need to be a way to bridge the gap and allow python developers to create smart contracts and decentralized applications on the Aleo blockchain. The Leo transpiler functions to transforms or convert python codes into formats compatible and suitable for the Aleo virtual machine.

The zkML transpiler is an open-source SDK that bridges Python — one of the most popular programming languages for machine learning developers — and zero-knowledge cryptography.

Developers can train their machine learning model as normal, then use the transpiler to convert the model into Leo, a ZK-friendly programming language compatible with Aleo’s zero-knowledge layer 1 solution.

The transpiler is currently implemented for decision tree models, a common type of machine learning algorithm that can create both classification and regression models. Eventually, it may be expanded to include random forest ML models, simple neural networks, linear regression models, and others.

We will be demonstrating the implementation of decision tree model using the Leo transpiler.

Load the Iris dataset and explore the data

We need to load and visualize our dataset that we would be using for this demonstration. this dataset is built into the sklearn library

# import the key libraries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
import logging
import os
from leotranspiler import LeoTranspiler

# Load the iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# take a look at the data
print(f"Data shape: {X.shape}")
print(f"Feature names: {iris.feature_names}")
print(f"Label names: {iris.target_names}")
print(f"First row: {X[0]}")
print(f"First label: {y[0]}")

The output will look like this

Split the data

Split the data into train and test sets in a ratio of 80:20

# Split the dataset into a training and a test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Create the decision tree classifier

# Create and train a decision tree classifier
clf = DecisionTreeClassifier(random_state=0)
clf.fit(X_train, y_train)

Output will look like this

Visualize the decision tree

Here we try to visualize the decision tree

# visualize the decision tree
plt.figure(figsize=(15, 7.5))
plot_tree(
    clf,
    filled=True,
    feature_names=iris.feature_names,
    class_names=iris.target_names.tolist(),
)
plt.show()

Output will look like this

Transpile the Python code into Leo code

First we need to set the logger and then transpiler the decision tree into leo code

# Set the logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# Transpile the decision tree into Leo code
lt = LeoTranspiler(model=clf, validation_data=X_train)
leo_project_path = os.path.join(os.getcwd(), "tmp")
leo_project_name = "tree1"
lt.to_leo(path=leo_project_path, project_name=leo_project_name)

Output will look like this

Checkout the transpiled leo code

Try to visualize the transpiled python code

# take a look at the transpiled code
leo_code_path = os.path.join(
    (os.path.join(leo_project_path, leo_project_name, "src", "main.leo"))
)
with open(leo_code_path, "r") as f:
    leo_code = f.read()
print(leo_code)

Output will look like this

Prove and compare the different predictions

Let's try one instance of the data on Leo and python models and compare the predictions and labels

For Leo model

We first perfect the prove and prediction using leo

# prove and compare the Leo prediction with the Python prediction and the label
zkp = lt.execute(input_sample=X_test[0])
python_prediction = clf.predict([X_test[0]])

print(f"Circuit constraints: {zkp.circuit_constraints}")
print(f"Leo prediction in fixed-point notation: {zkp.output[0]}")
print(f"Leo prediction in decimal notation: {zkp.output_decimal[0]}")
print(f"Python prediction: {python_prediction[0]}")
print(f"Label: {y_test[0]}")
print(f"Proof: {zkp.proof}")

Output will look like this

Next compute the accuracy

# Compute the accuracy of the Leo program on the test set
num_test_samples = len(X_test)
leo_predictions = np.zeros(num_test_samples)
for i in range(num_test_samples):
    leo_predictions[i] = lt.run(input_sample=X_test[i]).output_decimal[0]

# The leo accuracy 
leo_accuracy = np.sum(leo_predictions == y_test) / num_test_samples

For Python model

Then, we make the prediction using python:

# make the prediction using python 
python_predictions = clf.predict(X_test)
# The python accuracy 
python_accuracy = np.sum(python_predictions == y_test) / num_test_samples

Compare the two accuracies

print(f"Leo accuracy: {100*leo_accuracy} %")
print(f"Python accuracy: {100*python_accuracy} %")

Output will look like this

Thank you for following through with this demonstration

Website: https://www.aleo.org/

T witter : https://twitter.com/AleoHQ

G ithub : https://github.com/AleoHQ

D iscord : https://discord.com/invite/aleohq

This blog is a continuation of th Aleo ZKML on the Boston Housing dataset series. Please follow the link to check out the first part

In this blog we will be going further with aim of this blog to train the boston housing dataset using Aleo in order to preserve privacy of machine learning training.

Get Started

Import the necessary libraries which you will need for your analysis

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import numpy as np
import pandas as pd

Build the function to load data and split the data into test and train datasets

Build a function to load in the data to your work space

def load_data():
  data = pd.read_csv('./BostonHousing.csv')
  X = data.drop('medv', axis=1)    
  y = data['medv']    
  X = np.round(X).astype(int)    
  y = np.round(y).astype(int)
  return X, y

Load the data and return X and y

X, y = load_data()

Split the data into train and test sets in a ratio of 80:20

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Convert the train data to a list

X_train_leo = X_train.values.tolist()
y_train_leo = y_train.values.tolist()

Next we obtain our lineal regression model and fit the model to our train data

model = LinearRegression()
model.fit(X_train, y_train)

Next we get the model weights and intercepts and assign them to the variable weights and bias

weights = model.coef_
bias = model.intercept_

Scale the weights

We need to convert the weights and biases into integer, this will scale these parameters and our model.

# Scale weights and bias
weights_scaled = [int(w) for w in weights]
bias_scaled = int(bias)

Build the linear function

Build the prediction function for linear regression

# Perform the linear prediction
def linear_regression_predict(weights, features, bias):
    prediction = 0    
    for i in range(len(weights)):        
    prediction += weights[i] * features[i]    
    prediction += bias    
    return prediction
    

Feature scaling

Next we need to get the columns that have been scaled that is columns with weights = 0, then drop these columns from the X_test dataset, then convert it to a list. Also we need to get the weights that are not scaled that is weights that are not equal to 0

zero_weight_columns = X.columns[np.array(weights_scaled) == 0]
# Scale features for prediction
X_test = X_test.drop(zero_weight_columns, axis=1)
X_test_scaled = X_test.applymap(float_to_int).values.tolist()
weights_scaled = [weight for weight in weights_scaled if weight != 0]

Linear Regression with Aleo

Build the function that generates Aleo code for linear regression

#Utils function for generate aleo code linear_regression
def generate_aleo_code(weights, integer_type='i32'):    
    num_features = len(weights)    
    function_str = "transition linear_regression_predict("    
    # Add weight and feature arguments    
    for i in range(num_features):        
        function_str += f"weight{i}: {integer_type}, feature{i}: {integer_type}, "    # Add bias argument    function_str += f"bias: {integer_type}) -> {integer_type} {{\n"
    # Add body of function    
    function_str += f"let prediction: {integer_type} = "    
    for i in range(num_features):        
        function_str += f"weight{i} * feature{i} + "    
    function_str += "bias;\n"
    
    function_str += "return prediction;\n"    
    function_str += "}"
    return function_str

Generate new project

#generate new project aleo
!./leo new linear_regression

Next we replace the linear_regression.aleo program with our Aleo code generator function you earlier defined and write this into a file called content_program_aleo and save in the directory path 'linear_regression/src/main.leo'

#Fill code in main.leo
content_program_aleo = "program linear_regression.aleo { %code% }".replace('%code%', generate_aleo_code(weights_scaled))
with open('linear_regression/src/main.leo', 'w') as file:    
    file.write(content_program_aleo)

Import the necessary libraries

import os
from interp_leo.leo_uitls import convert_from_leo_type
from interp_leo.leo_program import LeoProgram

Train the Model

Here, we try to train the model through 102 iterations to obtain the predicted value for the target variable.

leo_program = LeoProgram(path=os.getcwd() + '/linear_regression')
y_pred_scaled = []
iter = 1
for x in X_test_scaled:  
    print('iteration', f"{iter}/{len(X_test_scaled)}")  
    value = leo_program.linear_regression_predict(*([val for pair in zip(weights_scaled, x) for val in pair] + [bias_scaled]))  
    y_pred_scaled.append(convert_from_leo_type(value))  
    iter += 1

Visualize our predicted values.

y_pred_scaled

Convert our y_pred_scaled back to numpy array

y_pred = np.array(y_pred_scaled)

Evaluation

Next we will be evaluating our model using the metric root mean squared error [RMSE]

Build the RMSE function

def rmse(y_true, y_pred):    
    '''    
    Compute Root Mean Square Percentage Error between two arrays.    
    '''    
    loss = np.sqrt(np.mean(np.square(((y_true - y_pred) / y_true)), axis=0))
    return loss

Print the RMSE error value

import numpy as np
y_test = np.array(y_test.apply(float_to_int))
print('🔥 RMSE error:', rmse(y_test, y_pred))

From the image we can see that our RMSE error is 0.43035

This is lower than what we got from Part 1 with RMSE error of 0.28489. There are continuous improvements and update of Aleo ZKML initiative.

Thank you for following through with this write-up on Aleo ZKML

Website: https://www.aleo.org/

T witter : https://twitter.com/AleoHQ

G ithub : https://github.com/AleoHQ

D iscord : https://discord.com/invite/aleohq

Introduction

Zero-knowledge machine learning (ZKML) is a relatively new field that focuses on training machine learning models without revealing the underlying data. For providing frameworks with inherent privacy-preserving properties in machine learning, Aleo can be used for this purpose especially in respect to ZKML.

In this blog we will be explaining the application of Aleo in ZKML using the Boston housing dataset. This dataset has found wide use in statistics and machine learning. The Boston housing dataset contains different house features for houses in Boston, Massachusetts in the united States. With 506 data points, this dataset is usually used in regression tasks for predicting house prices based on the given features.

We will be applying simple linear regression algorithm on the Boston dataset, this is used to establish a linear relationship between these features and the housing prices

Pre-requisite

This project was done on jupyter note book

Set up Aleo and Leo

You'll need to install Aleo and Leo and then set up the required environment. This sets up our environment and downloads Aleo and leo into our system or server.

run the code below;

!wget https://github.com/AleoHQ/leo/releases/download/v1.7.0/leo-v1.7.0-x86_64-unknown-linux-musl.zip
!unzip leo-v1.7.0-x86_64-unknown-linux-musl.zip
!rm -rf leo-v1.7.0-x86_64-unknown-linux-musl.zip

wait for the process to complete, you will get an image like similar to this

Get the dataset

Obtain the Boston dataset which we will be using for processing.

# Get the boston housing data
!wget https://gist.githubusercontent.com/icodragon/63ede7ff4478c680049aa353d1cefb11/raw/3985fb403e3c0839000c62396b49116be7d67692/BostonHousing.csv

Clone the Aleo zk-ML initiative

!git clone https://github.com/stakemepro/aleo-zkml-initiative-1.git && mv aleo-zkml-initiative-1/interp_leo interp_leo && rm -rf aleo-zkml-initiative-1

Without ZK

Import the necessary libraries which you will need for your analysis

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import numpy as np
import pandas as pd

Build a function to load in the data to your work space

def load_data():
  data = pd.read_csv('./BostonHousing.csv')
  X = data.drop('medv', axis=1)    
  y = data['medv']    
  X = np.round(X).astype(int)    
  y = np.round(y).astype(int)
  return X, y

Load the data and return X and y

X, y = load_data()

Split the data into train and test sets in a ratio of 80:20

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Convert the train data to a list

X_train_leo = X_train.values.tolist()
y_train_leo = y_train.values.tolist()

print(X_train_leo)print(y_train_leo)

Model

We are using a simple linear model for our analysis here. So we get our model and fit our linear model on our train data (X_train, y_train)

model = LinearRegression()
model.fit(X_train, y_train)

Next we get the model weights and intercepts and assign them to the variable weights and bias

weights = model.coef_
bias = model.intercept_

View the weights by calling the variable weights

weights

Prediction

Here, we make predictions using our linear model on the test dataset to obtain our predicted values for various values of y

Build the prediction function for linear regression

# Perform the linear prediction
def linear_regression_predict(weights, features, bias):
    prediction = 0    
    for i in range(len(weights)):        
    prediction += weights[i] * features[i]    
    prediction += bias    
    return prediction

Get the predicted values of y and assign the values as y_pred.

y_pred = [linear_regression_predict(weights, x, bias) for x in X_test.values.tolist()]

Next visualize our y_pred

y_pred

Evaluation

Next we will be evaluating our model using the metric root mean squared error [RMSE]

Build the RMSE function

def rmse(y_true, y_pred):    
    '''    
    Compute Root Mean Square Percentage Error between two arrays.    
    '''    
    loss = np.sqrt(np.mean(np.square(((y_true - y_pred) / y_true)), axis=0))
    return loss

Print the RMSE error value

import numpy as np
print('🔥 RMSE error:', rmse(np.array(y_test), np.array(y_pred)))

From the image we can see that our RMSE error is 0.28489

We will be continuing the Part II on the next update.

Follow this link to access the Part II

Website: https://www.aleo.org/

T witter : https://twitter.com/AleoHQ

G ithub : https://github.com/AleoHQ

D iscord : https://discord.com/invite/aleohq

Pre-requisites

Important Notice: You need to have a github account. If you already have a github account, you can proceed , but if you do not please to continue, create a github account following the link https://github.com/

Optional Pre requisite

Though this step is optionally, but it's advisable to go through with it cause this is best practice.

Create a new user

useradd danke 

You will be prompted to input your password, add your password

Then other name values like Full Name, Room Number, Work Phone etc. will request an input. Press enter to use the default values

Grant the user the permissions and switch to the user.

sudo usermod -aG sudo leo

Ensure to change to the user home directory

cd /home/danke

Update and install the necessary packages

sudo apt-get update && sudo apt-get install unzip && wget git -y

Create an access Token:
Follow the link: https://github.com/settings/tokens/new

Scroll down

Click on generate token

Note: Please save your token securely and never revel it to anyone

Variables

Next Set your variables

NICKNAME="Your_github_nickname" 
EMAIL="Your_github_email" 
TOKEN="Your_personal_access_token"

Replace "Your_github_nickname" with your github alias, replace "Your_github_email" with your email, and "Your_personal_access_token" with your saved secured token.

Configuration

Next configure your git

git config --global credential.helper store

configure your username and email

git config --global user.name $NICKNAME

git config --global user.email $EMAIL

git credential approve < <(echo "protocol=https host=github.com username=$NICKNAME password=$TOKEN")

Download the Aleo and Leo Binary

mkdir $HOME/aleo

wget https://github.com/AleoHQ/leo/releases/download/v1.9.5/leo-v1.9.5-x86_64-unknown-linux-musl.zip

unzip leo-v1.9.5-x86_64-unknown-linux-musl.zip -d $HOME/aleo

Add to $PATH and check

echo 'export PATH="$HOME/aleo:$PATH"' >> ~/.bashrc
source ~/.bashrc
leo --help

You will get an output like this:

Create the TicTacToe Game

Create the tictactoe game from the example given

leo example tictactoe

Change into the tictactoe directory

cd $HOME/tictactoe

Run a new game

leo run new

Make the script file executable

chmod +x run.sh

Start the game

./run.sh

Repo Preparation

Using git, prepare your repository

git init
git checkout -b main
git add .
git commit -m "My first commit"

Create a new Repository

Follow this link https://github.com/new

This repository should be empty without readme, license, gitignore files. Fill the repository name with any name you wish and then click on create repository

Next assign your repository link to a variable called LINK

LINK="https://github.com/user/.../.git"

Claim your badge​

1. Go to the Leo repo here
2. Give the repo a ⭐
3. Click "New Issue" in the top right corner
4. Click "Get started" in the Leo Contributor Badge row
5. Title your issue: "Add <your_github_username> to contributors"
6. Enter the following as your issue description:

Hi Aleo team! I'm claiming my contributor badge for completing the New Developer Toolkit tutorial.Tutorial Repo: <GITHUB_REPO_URL>Requested badge: <BADGE_TYPE

7. Click "Submit new issue"

8. Once your issue is approved, we will add you to the Contributors section of the Leo README.md file.

Congratulations on becoming a Leo contributor!

Website: https://www.aleo.org/
T witter : https://twitter.com/AleoHQ
G ithub : https://github.com/AleoHQ
D iscord : https://discord.com/invite/aleohq

Project Information

Official Information:

• Official site
• Documentation
• White paper
• Blog

DESCRIPTION

Fleek Network is a decentralized edge platform designed to make it easier to create and run performant web services (CDN, serverless operations, and so on). Fleek Network's globally distributed and autonomously controlled network of edge nodes enables developers to design and use a wide range of edge services with ease. These services inherit cryptographically and economically secure infrastructure, guaranteed node and geographic coverage, stable and predictable pricing, and uniform quality and performance across all network services. The purpose of Fleek Network is to provide a platform from which all Web3 protocols, middleware, services, and applications may further decentralize their stack without sacrificing cost, performance, complexity, or developer/end-user experience.

Server Requirements

Recommendations from the team (VPS/VDS/DS):
32 GB RAM, at least 20 GB SSD, Ubuntu 20.04

⠀ Suitable servers:

Update the server

sudo apt update 

Open the ports

sudo ufw allow 4300:4399/udp && sudo ufw allow 4200:4299/tcp

ufw allow 22 && ufw allow 4069 && ufw allow 4200 && ufw allow 6969 && ufw allow 18000 && ufw allow 18101 && ufw allow 18102

sudo ufw enable

Press y to accept and press enter

sudo ufw status 

Create a non-root user with administrative privileges.

Here, we used danke you can use whatever name you want, just replace danke with your chosen name.

adduser danke 

You will be prompted to input your password, add your password

Then other name values like Full Name, Room Number, Work Phone etc. will request an input. Press enter to use the default values

Grant the user the permissions and switch to the user.

usermod -aG sudo danke && su danke

Ensure to change to the user home directory

cd /home/danke

Install Fleek

curl https://get.fleek.network | bash

You will be required to select how you would like to run the Fleek network: select natively by typing 1 and pressing enter

type yes and press enter

type in your password and press enter

Then, allow your installation and compilation of Fleek to complete.

Press enter

press enter to continue

Then run this code to display you keys

lgtn keys show

Launch the Network node by running

sudo systemctl start lightning

Check the status of the service

sudo systemctl status lightning

press shift + q to exit

Registration

Check the health status of your node

curl -w "\p" localhost:4230/health

Your will get an output running

Head to metamask wallet

1. Add Fleek Network as a custom network in Metamask.
• Network Name: Fleek Network
• RPC URL: https://rpc.testnet.fleek.network/rpc/v0
• Chain ID: 59330
• Currency symbol: tFLK

go to https://faucet.testnet.fleek.network/ connect your wallet and make sure your selected network is the Fleek Network and click on Mint FLK

After a short while 1010FLK will appear in your wallet

Next click on the Stake FLK and you will get a pop up like the image below. Fill in your details

• The Node public key 🗝
• The consensus Public key 🗝
• your IP Address

Then click on stake to proceed

Confirm in your wallet. Then you get

run this again, this time you get running and staked

curl -w "\p" localhost:4230/health

To see the amount staked run, answer yes to the question prompts

curl https://get.fleek.network/node_details | bash

You can watch the Node output logs by running the command

tail -f /var/log/lightning/output.log

For diagnostics run the command:

tail -f /var/log/lightning/diagnostic.log

Run this script to get the health check overview:

curl -sS https://get.fleek.network/healthcheck | bash

enter yes for the answers to the prompt, output should look like this if everything works fine.

Congratulations

Update your node

To update your node, you need to log in as the user you registered , danke in my case

su danke

Then

cd ~/fleek-network/lightning 

git checkout testnet-alpha-0 && git stash

git pull origin testnet-alpha-0

Or run this script

curl -sS https://get.fleek.network/update | bash

Extra

stop the Network Node by running

sudo systemctl stop lightning

Restart the network by running

sudo systemctl restart lightning

You can watch the Node output by running the command

tail -f /var/log/lightning/output.log

For diagnostics run the command:

tail -f /var/log/lightning/diagnostic.log

GOOD LUCK

Social Media / Community

• Discord
• Github
• X

Sui is the first permissionless Layer 1 blockchain designed from the ground up to enable creators and developers to build experiences that cater to the next billion users in web3. It is a next-generation smart contract platform powered by Move, with high throughput, low latency, and an asset-oriented programming model.

Sui uses the Move programming language to define assets as objects that may be owned by an address.

Move programs define operations on these typed objects including custom rules for their creation, the transfer of these assets to new owners, and operations that mutate assets.

A permissionless group of authority that function similarly to validators or miners in other blockchain systems maintain Sui Network.

In contrast to Byzantine agreement, it ensures lower latency and improved scalability by using a Byzantine consistent broadcast protocol between authorities to protect shared actions on assets.

SETTING UP

Use the link below to install the Sui wallet

Sui wallet Extension

A. To be able to participate in the testing, you need to be in the Sui discord channel, join the SUI discord server using the link.

B. Navigate to the “testnet-faucet” channel and paste your wallet address using this format:

Note: replace your_wallet_address with you SUI wallet address you already installed earlier.

!faucet your_wallet_address

(example: !faucet 0xc598c2730134f10e2ee02d992145bd25a89c5458)

You will be credited with 0.5 SUI

• Log into your Sui wallet
• Click on the “Stake & Earn SUI” button.
• Select any validator from the list.
• Click “Select Amount”
• Enter the amount and click “Stake Now”.
• You can unstake your tokens only after 24 hours.

You will be able to see your staked SUI and the APY on your wallet Dashboard.

• Switch to “Apps” tab.
• Click on “Mint an NFT”
• You can view your minted NFTs by clicking on the “NFT” tab.

Done!

• Extra Mint NFT

https://testnft.suiecosystem.top
https://hanako.vercel.app
https://mint.vibrantpunks.xyz
https://test-wizardland.vercel.app

useful links

Official site of the project | Medium

Telegram announcement channel |Twitter | Discord | reddit

Link to web wallet