https://artela.network/blog/artela-tokenomics

Artela Network represents a cutting-edge blockchain platform designed to deliver high-performance, modular, and scalable solutions for fully on-chain AI agents. With groundbreaking technological innovations such as full-stack parallelization, multi-VM extensions, and elastic blockspace, Artela pushes the boundaries of blockchain technology while enabling seamless native AI integration. Following years of rigorous engineering development and months of successful testnet operations, Artela is now ready for its next big step—scaling to support millions of users and AI agents on-chain.

Today, we are excited to unveil the tokenomics of Artela, a comprehensive economic and incentive structure designed to ensure the platform's sustainability and scalability. The Artela economic model is a forward-looking approach that aligns incentives across all ecosystem participants, fostering a vibrant, thriving digital economy with the capacity to support billions of active participants.

1. ART Token: Introduction and Core Functions

The ART token is the native asset of the Artela Network, serving as a cornerstone of its operations. Designed to support transaction processing, governance, and decentralized applications, ART plays several critical roles within the ecosystem.

1.1 Key Functions of ART

1. **Staking:**ART tokens can be staked to participate in the proof-of-stake (PoS) consensus mechanism. Staking contributes to network security and stability while rewarding participants, thereby encouraging active engagement in network maintenance.

2. **Gas Fee Payment:**ART is used as the currency for gas fees, covering transaction and operation costs within the network. This ensures efficient and optimal resource allocation across the platform.

3. **Governance Power:**ART holders gain governance rights, enabling them to vote on important decisions such as protocol upgrades and resource allocation. This democratic mechanism empowers the community to shape the network’s future.

4. **Liquidity:**As a versatile and liquid asset, ART facilitates seamless transactions and interactions within the Artela ecosystem. This liquidity supports robust economic activity among users and developers.

In essence, ART is not just a token; it is the lifeblood of the Artela Network, driving security, governance, and liquidity while enabling innovation and community participation.

2. Staking, Governance, and Supply

Artela Network operates on a proof-of-stake (PoS) consensus mechanism, ensuring efficiency and security through an advanced blockchain infrastructure. Its in-protocol delegation system allows participants to stake ART either as validators or delegators, earning rewards in return. Validators charge delegators a fee, fostering collaboration in maintaining the network.

2.1 Inflation Model

ART follows a dynamic inflation model that starts at 8% annually and decreases by 1% per year until it reaches a long-term issuance rate of 0%. This controlled approach provides predictable supply growth, incentivizing early participation while transitioning toward a deflationary model for long-term value preservation.

2.2 Decentralized Governance

Governance within Artela Network is fully decentralized, empowering ART holders to propose and vote on changes to network parameters. This democratic structure ensures that all community members have a voice in shaping the platform. Detailed guidelines on governance participation are available, enabling active involvement in decision-making processes.

2.3 ART Allocation

The total supply of ART is 1,000,000,000 tokens, with no additional issuance beyond this fixed amount. Distribution is strategically designed to balance network growth, ecosystem development, and community involvement:

• Community (62%):

  • Airdrop (4.5%): Rewards for early participants in Artela’s development.

  • Network Staking (28.5%): Ensures long-term network security.

  • Ecosystem Development (23%): Incentives for AI agent and dApp developers.

  • Community Reserve (6%): Funds reserved for future expansion.

• Team (15%): Allocation for the core development team.

• Investors (18%): Distributed to institutional and individual investors.

• Early Contributors (5%): Rewards for advisors, partners, and early supporters.

2.4 Unlock Schedule

The token release schedule is carefully structured to ensure stability and transparency. This controlled unlocking process fosters confidence among ART holders and supports the ecosystem’s sustainable growth. Details of the unlock periods by category are outlined in accompanying charts and tables.

3. Conclusion

Artela’s economic model is intricately aligned with its technical architecture to create a scalable and sustainable system capable of supporting billions of users and AI agents. The ART token lies at the core of this vision, enabling security, governance, and liquidity while fostering ecosystem growth. By prioritizing fair initial distributions and a structured release schedule, Artela is laying the foundation for a thriving blockchain economy.

The journey ahead is full of promise, as the Artela ecosystem evolves and its community grows. Together, we are building a network that redefines the boundaries of blockchain and AI integration.

git clone https://github.com/cysic-labs/<repository-name>
cd <repository-name>
cargo build

3. Working with Elliptic Curves

Use elliptic curve operations in Rust:

use elliptic_curve::scalar::Scalar;

fn main() {
    let a = Scalar::from(123);
    let b = Scalar::from(456);
    let result = a * b;
    println!("Multiplication result: {:?}", result);
}

4. Implementing Zero-Knowledge Proofs

Create and verify a ZKP:

use zkp_toolkit::{Prover, Verifier};

fn main() {
    let (proof, public_input) = Prover::new().prove();
    let is_valid = Verifier::new().verify(proof, public_input);
    println!("Proof is valid: {:?}", is_valid);
}

5. GPU Parallel Computing

Utilize CUDA for GPU-based calculations:

__global__ void multiply_scalar(int *a, int *b, int *result) {
    int idx = threadIdx.x + blockIdx.x * blockDim.x;
    result[idx] = a[idx] * b[idx];
}

Run a Full Node

Testnet Configuration

• Chain ID: grimoria-testnet-1

• RPC: https://testnet-rpc.side.one

• Rest: https://testnet-rest.side.one

• gRPC: https://testnet-grpc.side.one:443

• Persistence Nodes: 6bef0693d7a31fed473b95123ad19b544b414093@202.182.119.24:26656,44f8009ed91fddd7ee51117482ede20fb4f33e78@149.28.156.79:26656

Hardware Requirement

• CPU: 4 cores

• RAM: 8 GB

• Storage: 500 GB

• Network: 1 Gbps

Build Sided from Source code

git clone https://github.com/sideprotocol/side.git
cd side
git checkout v0.9.0
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

Compile the sided binary:

make install
sided version

Adding keys to the keyring

sided keys add test --key-type="segwit"

Initialize the Node

sided init <MY_SIDE_VALIDATOR> --chain-id=grimoria-testnet-1

Download The Genesis file

wget https://raw.githubusercontent.com/sideprotocol/testnet/main/grimoria-testnet-1/genesis.json -O $HOME/.side/config/genesis.json

Adding seeds and persistent peers

cd $HOME/.side/config
nano config.toml

persistent_peers = "6bef0693d7a31fed473b95123ad19b544b414093@202.182.119.24:26656,44f8009ed91fddd7ee51117482ede20fb4f33e78@149.28.156.79:26656"

Set up min gas price

# in app.toml file
minimum-gas-prices = "0.005uside"

Start Node and Sync

sided tendermint unsafe-reset-all 
sided start

My Links

If you found this guide helpful or just liked it, you can learn more about me and subscribe to my social media. Do it, don't be lazy!

https://gax1nnt.gitbook.io/gax1nnt/

https://x.com/Gax1nnt

https://discord.com/users/846687399262289932

https://linktr.ee/Gax1nnt

Storage KV

Hardware Requirement

• Memory: 16 GB RAM

• CPU: 4 cores

• Disk: 500GB / 1T NVME SSD

• Bandwidth: 500 MBps for Download / Upload

Download the source code

git clone -b v1.1.0-testnet https://github.com/0glabs/0g-storage-kv.git

Build

cd 0g-storage-kv
git submodule update --init

# Build in release mode
cargo build --release

Configure

Copy the config_example.toml to config.toml and update the parameters

# rpc endpoint
rpc_listen_address
# ips of storage service, separated by ","
zgs_node_urls = "http://ip1:port1,http://ip2:port2,..."

# layer one blockchain rpc endpoint
blockchain_rpc_endpoint

# flow contract address
log_contract_address

# block number to start the sync, better to align with the config in storage service
log_sync_start_block_number

# storage nodes to download data from, separated by ","
# the provided nodes should cover full data in the storage network
zgs_node_urls

Run the kv service

cd run

# consider using tmux in order to run in background
../target/release/zgs_kv --config config.toml

My Links:

If you found this guide helpful or just liked it, you can learn more about me and subscribe to my social media. Do it, don't be lazy!

https://x.com/Gax1nnt

https://discord.com/users/846687399262289932

https://linktr.ee/Gax1nnt

https://gax1nnt.gitbook.io/gax1nnt/

Da Node

Hardware Requirement

• Memory: 16 GB

• CPU: 8 cores

• Disk: 1 TB NVME SSD

• Bandwidth: 100 MBps for Download / Upload

Installation

git clone https://github.com/0glabs/0g-da-node.git
git checkout tags/v1.0.1 -b v1.0.1
cargo build --release
./dev_support/download_params.sh

Configuration

Create a `config.toml` file:

log_level = "info"

data_path = "./db/"

# path to downloaded params folder
encoder_params_dir = "params/" 

# grpc server listen address
grpc_listen_address = "0.0.0.0:34000"
# chain eth rpc endpoint
eth_rpc_endpoint = "https://rpc-testnet.0g.ai"
# public grpc service socket address to register in DA contract
# ip:34000 (keep same port as the grpc listen address)
# or if you have dns, fill your dns
socket_address = "<public_ip/dns>:34000"

# data availability contract to interact with
da_entrance_address = ""
# deployed block number of da entrance contract
start_block_number = 0

# signer BLS private key
signer_bls_private_key = ""
# signer eth account private key
signer_eth_private_key = ""

# whether to enable data availability sampling
enable_das = "false"

Generate a BLS private key:

cargo run --bin key-gen

Run

./target/release/server --config cargo.toml

My Links

If you found this guide helpful or just liked it, you can learn more about me and subscribe to my social media. Do it, don't be lazy!

https://x.com/Gax1nnt

https://gax1nnt.gitbook.io/gax1nnt/

https://discord.com/users/846687399262289932

https://linktr.ee/Gax1nnt

Da Retriever Installation

Hardware Requirement

• RAM: 8GB

• CPU: 2 cores

• Bandwidth: 100 Mbps for download / upload

Install dependencies

sudo apt-get update
sudo apt-get install cmake build-essential protobuf-compiler

Install Rust:

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

Download the source code:

git clone https://github.com/0glabs/0g-da-retriever.git

Configuration

log_level - Set log level.
grpc_listen_address - Server listening address.
eth_rpc_endpoint - JSON RPC node endpoint for the blockchain network.

Run

Build in release mode:

cargo build --release

Run retriever:

./target/release/retriever --config ./run/config.toml

My Links:

If you found this guide helpful or just liked it, you can learn more about me and subscribe to my social media. Do it, don't be lazy!

https://x.com/Gax1nnt

https://linktr.ee/Gax1nnt

https://gax1nnt.gitbook.io/gax1nnt/

https://discord.com/users/846687399262289932