Paragon Protocol — DeFi, Evolved

Current State

Status

Transparent state of the stack. Planned means design or spec in progress, Alpha means usable but still changing, and GA means stable enough for wider use.

MoveVM runtime

Planned

Aptos-derived Move semantics and Block-STM execution.

DynamicGas

Planned

Programmable fee splits, burn paths, and validator-aligned incentives.

AICM v1

Planned

Job escrow, worker staking, proof submission, and settlement.

RWA Registry v1

Planned

Schemas, issuance, attestations, and rule enforcement.

L2 Manager v1

Planned

Rollup registry, light-client headers, and slashing framework.

TypeScript SDK

Alpha

Early client support for simulate, submit, and module integration.

System

Spec at a Glance

These are initial targets and can evolve as benchmarking and network tuning continue.

Aptos-derived MoveVM

Execution

Block-STM parallel execution

Consensus

HotStuff BFT variant

Block Time

≈ 1s target

Finality

≤ 2 blocks target

Gas Model

DynamicGas with burn + splits

Modules

AICM · RWA Registry · L2 Manager

Language

Move packages + Prover support

SDKs

TS alpha · Rust tooling · CLI

Compatibility

Aptos-style JSON-RPC model rather than EVM.
Move packages instead of Solidity deployment.
Deterministic resource access with parallel execution support.

Security defaults

Resource-oriented programming and safer asset semantics.
Move Prover support for stronger formal verification paths.
Governance-gated upgrades for long-term protocol control.

Builders

Quickstart (Coming Soon)

The goal is simple: write Move, test locally, simulate transactions, and later target public testnet with the same workflow.

Scaffold & Test

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

# 2) run unit tests
paragon move test

# 3) prove invariants
paragon move prove

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

Endpoints (planned)

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

Public testnet endpoints go live later. During alpha, development stays local-first.

Developer Surface

Developer APIs

Aptos-style JSON-RPC remains the base, with module-focused helpers layered on top to reduce boilerplate for AI, RWA, and L2 workflows.

Core APIs

POST /v1/transactions/simulate
POST /v1/transactions

GET  /v1/accounts/{address}
GET  /v1/accounts/{address}/resources
GET  /v1/accounts/{address}/modules

GET  /v1/blocks/{height}
GET  /v1/events/{handle}/{field}

Modules Gateway

POST /v1/aicm/jobs
POST /v1/aicm/proofs
GET  /v1/aicm/jobs/{job_id}

POST /v1/rwa/assets
GET  /v1/rwa/assets/{asset_id}
POST /v1/rwa/attestations

POST /v1/l2/register
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' });

// 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
});

const res = await pc.aicm.getJob(job.id);

Move Modules

Module Interfaces (v1)

Minimal surface area to start building cleanly, with room to expand later without breaking the core mental model.

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, with slashing for 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 is enforced through dedicated rules and attestation flows.

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>);
}

Designed to support rollup registry, proof updates, and slashing hooks.

Infrastructure

Node / Validator Requirements

Practical baseline targets for devnet and testnet. Mainnet requirements will likely be at least this strong, and probably stricter.

Hardware

CPU	8–16 vCPU (x86_64)
RAM	32–64 GB
Storage	1–2 TB NVMe
Bandwidth	1 Gbps preferred
OS	Ubuntu 22.04 LTS or compatible

Networking & Ops

Ports planned for P2P, RPC, and metrics exposure.
Prometheus metrics and health probes by default.
Snapshots, fast-sync, and optional archival modes.

Roadmap

Milestones

Phase 0 — Q3–Q4 2025

BNB Launch

ParagonSwap and Vaults
XPGN distribution and veXPGN gauges
Public dashboards and revenue visibility

Phase 1 — H1 2026

Public Testnet

Move toolchain, SDKs, faucet, and explorer
AICM v1, RWA v1, L2 Manager v1
Validator incentives and early bridge primitives

Phase 2 — 2026+

Mainnet L1

MoveVM core and DynamicGas
AI, RWA, and L2 modules productionized
DAO activation and live fee-sharing

Builders

Get Building

Start with Move

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

Move Quickstart

AICM Samples

Follow the full flow from job escrow to work, proof, and settlement.

Build an AI job

RWA Registry

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

Tokenize an asset