Paragon Chain

Overview for Builders

A Move-based L1 with native AI compute (AICM), RWA registry, modular rollups, and a dynamic gas model. Below is what exists today, what’s coming, and exactly how you’ll integrate.

Read Whitepaper v0.3 Join Early Access

Status

Transparent state of the stack. Planned = spec/design in progress,Alpha = usable but changing, GA = stable.

MoveVM runtime

Planned

Aptos-derived Move semantics & Block-STM.

DynamicGas (base burn + splits)

Planned

Programmable fee splits & tips.

AICM v1

Planned

Job escrow, worker staking, proof submit.

RWA Registry v1

Planned

Schemas, issuance, attestations, rules.

L2 Manager v1

Planned

Rollup registry, light client headers, slashing.

TypeScript SDK

Alpha

@paragon/ts — simulate & submit, AICM helper.

Spec at a Glance

Metrics below are initial targets (may tighten with benchmarks).

Aptos-derived MoveVM (Move semantics compatible)

Execution

Block-STM (parallel), deterministic writes

Consensus

HotStuff BFT variant

Block Time

≈ 1s (target)

Finality

≤ 2 blocks (target)

Gas Model

DynamicGas: base burn + tip + programmable splits

Modules (v1)

AICM · RWA Registry · L2 Manager

Language

Move packages + Move Prover support

SDKs

TS (alpha) · Rust (node/tools) · CLI (Move/AICM/RWA)

Compatibility

RPC: Aptos-style JSON-RPC (no EVM).
Move packages; no Solidity.
Deterministic resource access; parallel writes via Block-STM.

Security defaults

Resource-oriented programming; linear assets.
Formal verification via Move Prover (recommended).
Module upgradability gated by governance (DAO at mainnet).

Quickstart (COMING SOON)

Build with Move, simulate locally, then target public testnet when available.

Scaffold & Test

# 1) create a new Move package
paragon move new hello_paragon

# 2) run unit tests
paragon move test

# 3) prove invariants (optional)
paragon move prove

# 4) simulate a tx against local devnet
paragon devnet up
paragon tx simulate --sender 0xA1... --payload ./build/hello_paragon.mv

Endpoints (testnet, planned)

RPC:      https://rpc.test.paragonchain.org
Faucet:   https://faucet.test.paragonchain.org
Explorer: https://explorer.test.paragonchain.org

Endpoints go live with public testnet. During alpha, use local devnet via CLI.

Developer APIs

Aptos-style JSON-RPC plus module-specific REST helpers to reduce boilerplate.

Core (Aptos-style)

# simulate and submit a transaction
POST /v1/transactions/simulate
POST /v1/transactions

# read account state / resources
GET  /v1/accounts/{address}
GET  /v1/accounts/{address}/resources
GET  /v1/accounts/{address}/modules

# event & ledger
GET  /v1/blocks/{height}
GET  /v1/events/{handle}/{field}

Modules Gateway (v1)

# AICM: jobs & proofs
POST /v1/aicm/jobs                 # {model, input_uri, max_fee, timeout}
POST /v1/aicm/proofs               # {job_id, proof_blob, worker_addr}
GET  /v1/aicm/jobs/{job_id}

# RWA: registry
POST /v1/rwa/assets                # {issuer, schema_id, meta, rules}
GET  /v1/rwa/assets/{asset_id}
POST /v1/rwa/attestations         # {asset_id, attestor, payload, sig}

# L2 Manager: rollup registry
POST /v1/l2/register              # {rollup_id, type, bond}
GET  /v1/l2/{rollup_id}/lightclient
POST /v1/l2/{rollup_id}/prove

TypeScript Client (alpha)

import { ParagonClient } from '@paragon/ts';

const pc = new ParagonClient({ url: 'http://localhost:8080' }); // use local devnet in alpha

// simulate & submit
const sim = await pc.simulateTx({ sender, payload });
const tx  = await pc.submitTx(sim.signed);

// AICM job
const job = await pc.aicm.createJob({
  model: 'meta/llama-3-8b-instruct',
  input_uri: 'ipfs://Qm.../prompt.json',
  max_fee: '2500000',
  timeout: 120
});

// fetch result/proof
const res = await pc.aicm.getJob(job.id);

Module Interfaces (Move v1)

Minimal surface to start building; final names may remain the same with additions.

AICM

module AICM::Jobs {
  struct Job has key { id: u64, requester: address, model: vector<u8>, max_fee: u64, status: u8 }
  public fun create(account: &signer, model: vector<u8>, max_fee: u64, timeout_s: u64): u64;
  public fun submit_proof(worker: &signer, job_id: u64, proof: vector<u8>, gas_used: u64);
}

Workers stake via AICM::Stake; slashing on invalid proofs.

RWA Registry

module RWA::Registry {
  struct Asset has key { id: u64, issuer: address, schema: vector<u8> }
  public fun create_asset(issuer: &signer, schema: vector<u8>, meta: vector<u8>): u64;
  public fun add_attestation(attestor: &signer, asset_id: u64, payload: vector<u8>, sig: vector<u8>);
}

Compliance enforced via rule predicates in RWA::Rules.

L2 Manager

module L2::Manager {
  struct Rollup has key { id: u64, typ: u8, bond: u64, admin: address }
  public fun register(admin: &signer, typ: u8, bond: u64): u64;
  public fun update_light_client(relayer: &signer, rollup_id: u64, header: vector<u8>, proof: vector<u8>);
  public fun slash(rollup_id: u64, reason: vector<u8>);
}

Fee rebates streamed to validators via DynamicGas::Splits.

Node / Validator Requirements (initial)

Practical starting points for devnet/testnet. Mainnet requirements will be ≥ these.

Hardware

CPU	8–16 vCPU (x86_64)
RAM	32–64 GB
Storage	1–2 TB NVMe (SSD)
Bandwidth	1 Gbps up/down (min 200 Mbps sustained)
OS	Ubuntu 22.04 LTS (or compatible)

Networking & Ops

Ports: TCP 6180 (P2P), TCP 8080 (RPC), TCP 9101 (metrics)
Prometheus metrics & health probes exposed by default
Snapshots every N blocks; fast-sync toggle; archival mode optional

Milestones

Whitepaper v0.3

Phase 0 — Q3–Q4 2025

BNB Launch: ParagonSwap + Vaults

Dynamic fees, MEV guards, auto-compound vaults
XPGN distribution; veXPGN gauges
Public dashboards + buyback/POL reporting

Phase 1 — H1 2026

Public Testnet

Move toolchain + SDKs + faucet/explorer
AICM v1 + RWA v1 + L2 Manager v1
Validator incentives + light-client bridges (alpha)

Phase 2 — 2026+

Mainnet L1

MoveVM core + DynamicGas
AICM/RWA/L2 modules GA
DAO activation; fee-sharing live

Start with Move

Scaffold a package, run unit tests, prove invariants, and simulate transactions.

Move Quickstart

AICM Samples

End-to-end job: escrow → work → proof → settle. Includes GPU worker template.

Build an AI job

RWA Registry

Define a schema, issue an asset, attach attestations, and enforce rules.

Tokenize an asset