Quick Start

Up and running in 60 seconds.

Step 1 — Install the SDK

pip install vordium

Step 2 — Create your agent

from vordium import Agent

agent = Agent()
print(agent.address)
# 0x742d35Cc6634C0532925a3b8D4C9D5...
print(agent.balance)
# 0.0 VORD  (fund via the bridge or a transfer — there is no faucet)

Step 3 — Run autonomously

import asyncio
from vordium import Agent

agent = Agent()

async def strategy(agent):
    print(f"Block: {agent.block}")
    print(f"Balance: {agent.balance} VORD")

asyncio.run(agent.run(strategy=strategy))

Installation

Get the Vordium SDK running locally.

Python (recommended)

pip install vordium

Verify installation

vordium status
# Chain:    Vordium Chain
# Block:    5,026,000
# Status:   🟢 Online

From source

git clone https://github.com/Vordium/vordium-py
cd vordium-py
pip install -e .

Requirements

• Python 3.8+
• pip

AI Agents SDK Overview

Build autonomous agents that live on-chain.

The Vordium SDK is a first-class Python library for building AI agents that interact directly with Vordium Chain. It abstracts wallet management, transaction signing, balance tracking, and async execution — so you can focus on strategy logic.

What you can build

• Trading agents — autonomous market-making, arbitrage, momentum strategies.
• AI-driven agents — LLMs making decisions on-chain via Claude or GPT-4.
• Monitoring bots — react to block events, balance changes, contract calls.
• Protocol automation — keeper bots, liquidators, yield optimizers.

Python SDK

Full reference for vordium v0.2.0 — install with pip install vordium

VordiumClient

from vordium import VordiumClient

client = VordiumClient("0x_your_private_key")

Prices & Markets

markets = client.get_markets()          # All perp markets with prices
rates = client.get_funding_rates()      # Current funding rates
pool = client.get_pool_stats()          # VLP pool mark-to-market

Perpetual Trading

# Open a long position
result = client.open_position(
    pair_id=1,       # ETH=1, BTC=2, BNB=3, SOL=4, ARB=6, AVAX=8
    is_long=True,
    margin=10.0,     # $10 USDC
    leverage=5,
)

# Get open positions
positions = client.get_positions()

# Close a position (full or partial)
client.close_position(position_id=1)
client.close_position(position_id=1, close_size=0.005)

# Set take-profit and stop-loss
client.set_tp_sl(
    position_id=1,
    tp_price=2500.0,
    sl_price=2100.0,
)

Order Book

book = client.get_orderbook(pair_id=1)  # ETH order book
stats = client.get_stats()              # Engine health & stats

Pair IDs

Pairs are loaded dynamically from /api/pairs/perps. All pairs support up to 100x leverage. Use the endpoint to get the current list of pair IDs, symbols, and parameters.

JavaScript SDK

Connect to Vordium via ethers.js or the engine REST API.

Direct RPC (ethers.js)

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(
  "https://rpc.vordium.com", 713714, { staticNetwork: true }
);
const block = await provider.getBlockNumber();
console.log("Block:", block);

Engine API (REST)

VordCore exposes REST endpoints for trading:

const ENGINE = "https://rpc.vordium.com";

// Get markets and prices
const markets = await fetch(`${ENGINE}/v1/perp/markets`).then(r => r.json());

// Get positions for a wallet
const positions = await fetch(`${ENGINE}/v1/perp/positions/${address}`).then(r => r.json());

// Get funding rates
const funding = await fetch(`${ENGINE}/v1/funding`).then(r => r.json());

// Get pool mark-to-market value
const pool = await fetch(`${ENGINE}/v1/pool`).then(r => r.json());

// Get engine stats
const stats = await fetch(`${ENGINE}/stats`).then(r => r.json());

Open a Perp Position

import { ethers } from "ethers";

const sessionWallet = new ethers.Wallet(SESSION_KEY);
const payload = {
  action: "perp_open",
  wallet: ownerAddress,
  pairId: 1,           // ETH
  isLong: true,
  leverage: 5,
  margin: "10.000000", // $10 USDC
};

const signature = await sessionWallet.signMessage(JSON.stringify(payload));

const result = await fetch(`${ENGINE}/v1/perp/open`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ ...payload, signature, sessionWallet: sessionWallet.address }),
}).then(r => r.json());

console.log("Position ID:", result.positionId);

CLI Reference

The vordium command.

Initialize agent

vordium init

Check chain status

vordium status

Check balance

vordium balance
vordium balance 0x...

Send VORD

vordium send 0xRecipient 10.0

Run an agent script

vordium run my_agent.py

Interactive mode

vordium

Examples

Real agent patterns you can copy.

Example 1 — Hello Vordium

from vordium import Agent, Chain

chain = Chain()
print(f"Block: {chain.block_number:,}")
print(f"Connected: {chain.connected}")

agent = Agent()
print(f"Address: {agent.address}")
print(f"Balance: {agent.balance} VORD")

Example 2 — Autonomous Agent

import asyncio
from vordium import Agent

agent = Agent()

async def my_strategy(agent):
    block = agent.block
    balance = agent.balance
    print(f"Block {block:,} | {balance:.4f} VORD")
    # Add your trading logic here

asyncio.run(agent.run(
    strategy=my_strategy,
    interval=1.0  # Run every second
))

Example 3 — Send VORD

from vordium import Agent

agent = Agent()
print(f"Balance: {agent.balance} VORD")

tx = agent.send(
    to="0xRecipient...",
    amount=10.0
)
print(f"Sent! TX: {tx}")

Example 4 — Claude AI Agent

Use Claude Opus 4.6 to make live trading decisions.

import asyncio
from anthropic import Anthropic
from vordium import Agent

claude = Anthropic()
agent = Agent()

async def ai_strategy(agent):
    response = claude.messages.create(
        model="claude-opus-4-6",
        max_tokens=200,
        messages=[{
            "role": "user",
            "content": f"""
You are a trading agent on Vordium Chain.
Block: {agent.block}
Balance: {agent.balance} VORD

What should I do? Reply with one word:
BUY, SELL, or HOLD
"""
        }]
    )
    decision = response.content[0].text.strip()
    print(f"AI Decision: {decision}")

asyncio.run(agent.run(strategy=ai_strategy))

VordiumBFT Consensus

~100ms block time. Sub-400ms finality.

What is VordiumBFT?

VordiumBFT is a custom Byzantine Fault Tolerant consensus engine built for Vordium Chain. It achieves ~100ms block times with single-slot finality — once a block is produced, it is final. No reorgs. No confirmation waits.

How it works

VordiumBFT uses a streamlined propose-vote-commit pipeline optimized for low-latency environments:

• Block proposer broadcasts a new block
• Validators vote in a single round
• 2/3+ votes = block is committed and final
• No multi-round finality gadget needed

Validator Set

Vordium runs with 5 validators operating BFT consensus. The validator set ensures fault tolerance while maintaining high throughput (~100ms blocks).

Why not Tendermint/CometBFT?

Standard CometBFT achieves ~400ms blocks. VordiumBFT strips unnecessary overhead — no mempool gossip delay, no prevote/precommit rounds, no separate ABCI layer — to cut block time by 4x. The 5-validator set balances throughput with fault tolerance for a trading-focused chain.

Become a Validator

Run a node, bond VORD, and join the active set — securely.

Overview

Vordium validators secure the chain via VordiumBFT. New validators join through apply → approve → download → register → seed → join, and all set changes apply at epoch boundaries so membership never diverges between nodes.

Requirements

Security checklist

Follow these before you register — most are one-time hardening steps.

Keys (most important)

• Your validator signing key and VRF seed are generated ON the node itself at first boot. Never copy, paste, transport, or reuse a private key.
• NEVER run two nodes with the same validator key. Double-signing is equivocation — 5% of your bond is slashed and you are permanently tombstoned (you can never rejoin). One node per key, always. This is the single biggest risk.
• Back up the key files encrypted (e.g. age or gpg) off-box; store the passphrase separately.
• Keep the operator/withdrawal wallet that holds your 1,000,000 VORD bond in a hardware wallet, separate from the node. The node never needs your withdrawal private key.

Node & OS hardening

• Dedicated server — do not co-host other apps or websites on it.
• Firewall: allow inbound only the BFT gossip port (9000) and SSH; bind the RPC/admin ports (9002, 8545) to 127.0.0.1 — never expose them publicly.
• SSH: key-only authentication; disable password login and root-password login; enable fail2ban.
• Enable unattended security updates; keep the OS minimal.

Reliability

• 16 GB RAM. If swap is 0, add swap or memory alerting — an out-of-memory kill takes the node down silently, and downtime is slashed.
• SSD storage, stable network, static public IP.
• Sync the clock with NTP — BFT consensus is timing-sensitive.
• Run the node under systemd with auto-restart; rotate logs.

Monitoring

• Alert on: node process down, block height falling behind the network, and rising missed-slot count.
• Missed slots accrue toward downtime slashing (jail).

How to onboard (step by step)

1. Apply — submit your identity only: operator address, node name, and endpoint (host:port). No node keys and no bond are required to apply.
2. Get approved — an operator reviews your application (with your live VORD balance) and approves your candidate address. Approval must come BEFORE you can download or register.
3. Download — on approval you receive a one-time, time-limited link to download the node binary and the genesis file. The binary is never public — it is served only to approved operators.
4. Provision & first boot — on a dedicated Linux box, install the downloaded binary + genesis and the boot config (BFT listen :9000, peers = the current validators). On first boot the node generates and LOGS its VRF public key and derives its operator address (both public; keys never leave the box).
5. Sync — the node joins as a non-validator full node and catches up to the live head. Confirm it reaches "live" and its head matches the network.
6. Fund — hold at least 1,000,000 VORD at your operator address (your self-bond), or ask the operator to seed the bond from the treasury.
7. Register — submit your on-node VRF + signing pubkeys and endpoint (RegisterValidator). The operator accepts and, if seeding, funds the 1,000,000 bond.
8. Join — at the next epoch boundary your node enters the active set and starts producing and voting.

Slashing & parameters

All values below are chain-enforced:

Field reference

Each field on the register form below maps to the following:

Become a validator →

Live network status: rpc.vordium.com/status · Explorer: see Block Explorer.

Perpetuals Trading Guide

How to trade perpetual futures on Vordex.

Overview

Vordex perpetual futures are executed by VordCore, the native execution layer. VordCore handles order matching, TP/SL monitoring, liquidation checks, funding rate calculation, and settlement. All operations execute with instant BFT finality on Vordium Chain.

Available Markets

All markets support up to 100x leverage. The full pair list is loaded dynamically from the chain via /api/pairs/perps. Current markets include ETH, BTC, BNB, SOL, POL, ARB, OP, AVAX, LINK, UNI, DOGE, XRP, ADA, DOT, SUI, LTC, 1INCH, and ARKM — with new pairs added on-chain without code changes.

How it works

1. Deposit USDC to your Vordex vault via the Arbitrum bridge
2. Enable trading by creating a session key (signs trades without your main wallet)
3. Open a position — choose pair, leverage (up to 100x), and margin
4. Set TP/SL — the engine monitors prices every second and auto-closes at your targets
5. Close — full or partial close at market price

Funding Rates

Funding is charged hourly using the Hyperliquid/Lighter formula: rate = avgPremium + clamp(interestRate - avgPremium). Base rate: 0.01% per 8 hours. When rate is positive, longs pay shorts. When negative, shorts pay longs. The pool (VLP) is not involved in funding — it is purely peer-to-peer.

Liquidation

Positions are liquidated when equity falls below the maintenance margin. The liquidation engine checks every block. If a liquidation creates bad debt (loss exceeds margin), ADL (auto-deleveraging) engages to close the most profitable opposing positions.

VLP Pool

The VLP pool acts as counterparty to all trades. Depositors earn when traders lose, and lose when traders win. Pool value is marked-to-market in real time. Deposits have a 1-hour lockup (testnet). The pool's realPoolValue is available at /v1/pool.

Session Keys

Trade without signing every transaction.

What are Session Keys?

Session keys are temporary signing keys that authorize VordCore to execute trades on your behalf. Your main wallet stays safe — it never signs trade transactions directly. This is the same model used by Hyperliquid.

How it works

1. Go to the Portfolio page and click Enable Trading
2. Your wallet produces one EIP-712 signature (no gas, no on-chain tx) authorizing the session key, which is POSTed to the VordCore session API
3. The session key is stored in your browser (localStorage)
4. All subsequent trades are signed by the session key, not your main wallet
5. Sessions expire after a set duration (currently 24 hours)

Security

Session keys can only execute trades — they cannot withdraw funds or transfer ownership. If a session key is compromised, an attacker could only place trades (which are bounded by your vault balance and position limits). You can revoke a session at any time from the Portfolio page.

VordCore Session API

Sessions are native VordCore state (no on-chain contract, no gas). The owner signs an EIP-712 SessionCreate message; the signature is submitted to the session API, which routes it through consensus. The API is proxied at rpc.vordium.com/session/* and served natively on each validator's port 9001.

# Create session — owner-signed EIP-712 (see typed data below)
POST https://rpc.vordium.com/session/create
Body: { "owner": "0x...", "session_key": "0x...", "expires_at": 1699999999, "nonce": 1, "signature": "0x..." }
# -> 200 {"success":true,"status":"submitted"}  (401 if the signature is missing/invalid)

# Revoke the active session for an owner (owner-signed)
POST https://rpc.vordium.com/session/revoke
Body: { "owner": "0x...", "nonce": 2, "signature": "0x..." }

# Check session validity / read the active session
GET https://rpc.vordium.com/session/valid?owner=0x...&session_key=0x...   # -> {"valid":true|false}
GET https://rpc.vordium.com/session/get?owner=0x...

EIP-712 typed data

The SessionCreate message is signed under the shared VordCore domain. Signatures are 64-byte r‖s (the v byte is stripped; the verifier brute-forces the recovery id).

// EIP-712 domain (shared by all VordCore user ops)
const domain = {
  name: "VordexSession",
  version: "1",
  chainId: 713714,
  verifyingContract: "0x0000000000000000000000000000000000001002",
};
const types = {
  SessionCreate: [
    { name: "sessionKey", type: "address" },
    { name: "expiresAt",  type: "uint256" },
    { name: "nonce",      type: "uint256" },
  ],
};
const value = { sessionKey, expiresAt, nonce };
const sig65 = await wallet.signTypedData(domain, types, value);   // browser / ethers v6
const signature = "0x" + sig65.slice(2, 130);                     // 64-byte r‖s (strip v)

await fetch("https://rpc.vordium.com/session/create", {
  method: "POST", headers: { "content-type": "application/json" },
  body: JSON.stringify({ owner, session_key: sessionKey, expires_at: expiresAt, nonce, signature }),
});

Bridge Guide (Arbitrum)

Move USDC from Arbitrum to Vordium and back.

How Bridging Works

Vordex uses a bridge relayer that watches deposits on the Arbitrum side and mints equivalent BUSDC (Bridged USDC) on Vordium. BUSDC is the trading currency on Vordex — it has 6 decimals and is pegged 1:1 to USDC.

Deposit (Arbitrum → Vordium)

1. Go to the Portfolio page
2. Click Deposit — this connects to the Arbitrum bridge contract
3. Approve and deposit USDC on Arbitrum
4. The relayer detects your deposit and credits your Vordex vault within ~30 seconds
5. Your BUSDC appears in your vault freeBalance

Withdraw (Vordium → Arbitrum)

1. Go to Portfolio and click Withdraw
2. Enter the amount — a withdrawal request is submitted on Vordium
3. The relayer processes the withdrawal and sends USDC to your wallet on Arbitrum
4. Minimum withdrawal: $1 USDC. Withdraw fee: $1 USDC

Contracts

Network Information

Everything you need to connect to Vordium Chain.

Add to Wallet

One click to add Vordium Chain to MetaMask.

Manual setup

RPC Endpoints

Public endpoints for Vordium Chain.

All endpoints are CORS-enabled. Primary RPC accepts both Ethereum JSON-RPC and VordCore REST API calls.

Block Explorer

VordScan — view every transaction on Vordium.

VordScan is a fully-featured block explorer for Vordium Chain. Search by address, transaction hash, block number, or token.

VRC-20 Tokens

Vordium's fungible token standard.

VRC-20 extends ERC-20 with Vordium-specific features including on-chain chain verification.

New functions

chainId()        // returns 713714
tokenStandard()  // returns "VRC-20"
nativeChain()    // returns "Vordium"

Deploy a VRC-20

pip install vordium
vordium init

Deploy with Foundry

forge create VRC20.sol:VRC20 \
  --rpc-url https://rpc.vordium.com \
  --private-key $PRIVATE_KEY \
  --constructor-args "MyToken" "MTK" 18 1000000

VRC-721 NFTs

Non-fungible tokens on Vordium.

tokenStandard()  // returns "VRC-721"
chainId()        // returns 713714

VRC-1155 Multi-Token

Multi-token standard for fungible + non-fungible assets in one contract.

tokenStandard()  // returns "VRC-1155"
chainId()        // returns 713714

Deploy a Contract

Full guide to deploying Solidity contracts on Vordium.

Step 1 — Install Foundry

curl -L https://foundry.paradigm.xyz | bash
source ~/.bashrc
foundryup

Step 2 — Create an ERC-20

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("My Token", "MTK") {
        _mint(msg.sender, 1000000 * 10**18);
    }
}

Step 3 — Deploy

forge create MyToken.sol:MyToken \
  --rpc-url https://rpc.vordium.com \
  --private-key $PRIVATE_KEY

Step 4 — Verify on VordScan

1. Open vordscan.io
2. Search your contract address
3. Submit source for verification

Verify Contract

Publish source code on VordScan.

Open your contract page on vordscan.io, click Verify Contract, paste your Solidity source, select the compiler version, and submit. Verified contracts display source, ABI, and a read/write UI.

RPC API Reference

Standard Ethereum JSON-RPC over HTTPS.

Get block number

curl -X POST https://rpc.vordium.com \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

Response:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x155a76"
}

Get balance

curl -X POST https://rpc.vordium.com \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": ["0x...", "latest"],
    "id": 1
  }'

Get chain ID

curl -X POST https://rpc.vordium.com \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_chainId",
    "params": [],
    "id": 1
  }'

Response: {"result": "0xae3f2"}

Supported methods

eth_chainId
eth_blockNumber
eth_getBalance
eth_sendRawTransaction
eth_getTransactionByHash
eth_getTransactionReceipt
eth_call
eth_estimateGas
eth_gasPrice
net_version
web3_clientVersion

WebSocket Guide

Subscribe to real-time chain events.

const ws = new WebSocket("wss://rpc.vordium.com/ws");

ws.onopen = () => {
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_subscribe",
    params: ["newHeads"]
  }));
};

ws.onmessage = (e) => {
  const data = JSON.parse(e.data);
  console.log("New block:", data);
};

Vordex Trading Guide

Trade on the Vordium Chain decentralized exchange.

Vordex is the native DEX on Vordium Chain, featuring an on-chain orderbook with 10 trading pairs and support for AI agent trading.

Getting started

1. Connect MetaMask — visit app.vordex.io and connect your wallet.
2. Switch to Vordium Chain — ensure your wallet is on Chain ID 713714.
3. Deposit USDC to vault — you must deposit USDC into the Vault contract before placing orders.
4. Place orders — choose a trading pair and place limit or market orders.

Key details

AI agent trading

AI agents can trade programmatically by interacting with the Orderbook contract directly. Deposit USDC to the Vault, then call placeOrder or placeMarketOrder on the Orderbook contract to execute trades.

Vordex API

REST API for market data, trading, and account management.

Base URL: https://rpc.vordium.com. All endpoints return JSON with { success, data, timestamp }. Query parameter ?network=mainnet|testnet selects the network (default varies by endpoint).

Market Data

GET /health

curl https://rpc.vordium.com/health

{ "status": "ok", "chain": "Vordium", "chainId": 713714 }

GET /v1/price/:symbol

Oracle price for a single symbol.

curl https://rpc.vordium.com/v1/price/ETH

{ "symbol": "ETH", "pair": "ETH/USDC", "pairId": 1, "price": "2184.71" }

GET /v1/price/all

Oracle prices for all 11 trading pairs. Cached for 3 seconds.

curl https://rpc.vordium.com/v1/price/all

GET /v1/candles/:symbol

OHLCV candlestick data. Intervals: 1m, 3m, 5m, 15m, 30m, 1h, 4h, 1d. Max 500 candles.

curl "https://rpc.vordium.com/v1/candles/ETH?interval=1h&limit=100"

{
  "data": [
    { "time": 1775739600, "open": "2183.33", "high": "2186.54", "low": "2158.19", "close": "2165.22", "volume": "16119.36" }
  ],
  "symbol": "ETH", "interval": "1h", "count": 100
}

GET /v1/trades/:symbol

Recent on-chain trades from TradeExecuted events. Max 200.

curl "https://rpc.vordium.com/v1/trades/ETH?network=mainnet&limit=50"

{
  "data": [
    { "symbol": "ETH", "price": "2184.50", "amount": "0.5", "buyer": "0x...", "seller": "0x...", "buyerIsAgent": true, "txHash": "0x..." }
  ]
}

GET /v1/orderbook/:symbol

Live orderbook with bids and asks. Params: ?network=mainnet&depth=10 (max 50).

curl "https://rpc.vordium.com/v1/orderbook/ETH?network=mainnet&depth=10"

{
  "data": {
    "symbol": "ETH", "midPrice": "2184.710000",
    "bids": [{ "id": "42", "price": "2184.00", "amount": "1.5", "isAgent": false }],
    "asks": [{ "id": "43", "price": "2185.00", "amount": "2.0", "isAgent": true }]
  }
}

Trading

POST /v1/order

Place a signed limit or market order. The API verifies the signature and relays the transaction on-chain.

curl -X POST https://rpc.vordium.com/v1/order \
  -H "Content-Type: application/json" \
  -d '{
    "symbol": "ETH",
    "side": "buy",
    "type": "limit",
    "price": "2000.0",
    "amount": "0.1",
    "network": "testnet",
    "trader": "0xYourAddress",
    "signature": "0xSignedMessage",
    "nonce": 1712678400
  }'

Signature: Sign keccak256(abi.encodePacked(symbol, side, type, price, amount, nonce)) with the trader's private key.

{
  "data": { "orderId": "123", "symbol": "ETH", "side": "buy", "price": "2000.0", "amount": "0.1", "status": "open", "txHash": "0x..." }
}

POST /v1/order/batch

Place up to 10 orders in a single request. All orders are submitted sequentially on-chain.

curl -X POST https://rpc.vordium.com/v1/order/batch \
  -H "Content-Type: application/json" \
  -d '{
    "orders": [
      { "symbol": "ETH", "side": "buy", "price": "2000", "amount": "0.1" },
      { "symbol": "BTC", "side": "sell", "price": "72000", "amount": "0.01" }
    ],
    "trader": "0xYourAddress",
    "signature": "0xSignedMessage",
    "nonce": 1712678400,
    "network": "testnet"
  }'

Signature: Sign keccak256(abi.encodePacked("batch", orderSummary, nonce)) where orderSummary is each order's fields concatenated.

DELETE /v1/order/:orderId

Cancel a specific order by ID. Verifies the signature and that the order belongs to the trader.

curl -X DELETE https://rpc.vordium.com/v1/order/42 \
  -H "Content-Type: application/json" \
  -d '{
    "trader": "0xYourAddress",
    "signature": "0xSignedMessage",
    "nonce": 1712678400,
    "network": "testnet"
  }'

Signature: Sign keccak256(abi.encodePacked("cancel", orderId, nonce)).

DELETE /v1/order/cancel-all

Cancel all open orders for a trader. Finds open/partial orders and cancels each on-chain.

curl -X DELETE https://rpc.vordium.com/v1/order/cancel-all \
  -H "Content-Type: application/json" \
  -d '{
    "trader": "0xYourAddress",
    "signature": "0xSignedMessage",
    "nonce": 1712678400,
    "network": "testnet"
  }'

Signature: Sign keccak256(abi.encodePacked("cancel-all", nonce)).

{
  "data": { "trader": "0x...", "totalOrders": 15, "openOrders": 3, "cancelled": 3, "cancelledIds": ["10", "12", "14"] }
}

Account & Orders

GET /v1/account/:address

Vault balances and agent status. Params: ?network=mainnet.

curl "https://rpc.vordium.com/v1/account/0xYourAddress?network=mainnet"

{
  "data": { "address": "0x...", "freeBalance": "10000.00", "lockedBalance": "2500.00", "totalBalance": "12500.00", "isAgent": false }
}

GET /v1/orders/:address

Last 50 orders for a trader with status, fill amount, and agent flag.

curl "https://rpc.vordium.com/v1/orders/0xYourAddress?network=mainnet"

GET /v1/fills/:address

Recent fill history from TradeExecuted events. Shows buys and sells for the address.

curl "https://rpc.vordium.com/v1/fills/0xYourAddress?network=mainnet"

{
  "data": [
    { "symbol": "ETH", "side": "buy", "price": "2184.50", "amount": "0.5", "usdcSettled": "1092.25", "txHash": "0x..." }
  ]
}

Protocol

GET /v1/agents

List all registered AI agents with trade stats.

curl https://rpc.vordium.com/v1/agents

GET /v1/agents/:address

Check if an address is a registered agent.

curl https://rpc.vordium.com/v1/agents/0xAgentAddress

GET /v1/stats

Protocol-wide statistics: TVL, total orders, agent vs human trade counts.

curl https://rpc.vordium.com/v1/stats

{
  "data": { "totalPairs": 11, "totalOrders": 0, "tvl": "500.0", "agentTrades": 0, "humanTrades": 0 }
}

GET /v1/leaderboard

Top traders ranked by volume. Params: ?type=agents|all&network=mainnet.

curl "https://rpc.vordium.com/v1/leaderboard?type=agents"

GET /v1/pairs

All available trading pairs with pair IDs.

curl https://rpc.vordium.com/v1/pairs

GET /v1/network

Chain info, block height, and all contract addresses.

curl https://rpc.vordium.com/v1/network

All 18 endpoints

Orderbook

VordCore native orderbook for all trading pairs.

The orderbook is managed natively by VordCore. There is no on-chain orderbook contract. All order placement, matching, and settlement happen through the VordCore execution layer with instant BFT finality. Prices are in 1e6 format (e.g. ETH at $2300 = 2300000000). Sizes are in 1e18 format.

Side values

• 0 = Buy
• 1 = Sell

Pair IDs

VordCore API

# Place an order (requires session key)
POST https://rpc.vordium.com/order/place
Body: { pair_id, side: "Buy"|"Sell", size, owner, session_key, order_type: "Market"|"Limit", price, leverage, signature }

# Cancel an order
POST https://rpc.vordium.com/order/cancel
Body: { order_id, owner, signature, session_key }

# Get orderbook
GET https://rpc.vordium.com/orderbook/{pair_id}

# Get open orders for address
GET https://rpc.vordium.com/orders/{address}
function getAvailableLiquidity(uint256 pairId, uint8 side, uint256 worstPrice) external view returns (uint256);
function getPairBids(uint256 pairId) external view returns (Order[] memory);
function getPairAsks(uint256 pairId) external view returns (Order[] memory);

Example — Place a limit buy order

// Place a limit order via VordCore REST API
const res = await fetch("https://rpc.vordium.com/order/place", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    pair_id: 1,              // ETH
    side: "Buy",
    order_type: "Limit",
    price: 2300000000,       // $2300 in 1e6 format
    size: 1000000000000000000, // 1 ETH in 1e18
    session_key: sessionAddress,
    signature: sig
  })
});
console.log("Order placed");

Vault

USDC vault for Vordex trading collateral.

Users must deposit USDC into the Vault before placing orders on the Orderbook. The Vault tracks free and locked balances per user. Locked balance represents funds tied to open orders.

USDC on Vordium uses 6 decimals.

Deposit

Deposits are not a vault method call. Deposit USDC into the Arbitrum bridge; the relayer credits your Vordium vault (BUSDC) within ~30s. See the Bridge Guide.

Read balances (REST)

# USDC vault balance for an address (all fields 6 decimals)
GET https://rpc.vordium.com/balance/{address}
# -> { "total":0, "free_balance":0, "locked":0, "available":0,
#      "reserved":0, "in_positions":0, ... }

# Vault / reserve totals
GET https://rpc.vordium.com/reserves
# -> { "total_usdc_vault": 0, "vlp_pool_value": 0, ... }

Example — read your vault balance

const res = await fetch(`https://rpc.vordium.com/balance/${address}`);
const b = await res.json();
console.log("free USDC:", b.free_balance / 1e6);
console.log("locked USDC:", b.locked / 1e6);
console.log("total USDC:", b.total / 1e6);

Withdrawals are submitted as an EIP-712-signed request routed through consensus (the relayer pays out USDC on Arbitrum) — see the Bridge Guide. There is no withdraw() contract method.

Oracle

VordCore native oracle with 8 CEX sources.

VordCore aggregates prices from 8 centralized exchanges: Binance, OKX, Bybit, Kraken, KuCoin, Gate.io, MEXC, and its own mid price. Outlier rejection ensures accuracy. There is no on-chain oracle contract.

REST API

# Get oracle price for a pair
GET https://rpc.vordium.com/oracle/{pair_id}

# Response:
{
  "pair_id": 1,
  "oracle_price": 2310905000,    // price * 1e6
  "mark_price": 2310907500,
  "index_price": 2310905000,
  "sources_used": 7,
  "funding_rate_bps": 1,
  "change_24h_pct": -0.0793,
  "high_24h": 2312.74,
  "low_24h": 2310.90,
  "volume_24h": 169179021.54
}

Pair IDs: ETH=1, BTC=2, BNB=3, SOL=4, POL=5, ARB=6, OP=7, AVAX=8, LINK=9, UNI=10, DOGE=11, XRP=12, ADA=13, DOT=14, SUI=15.

Example — Read ETH price

const res = await fetch("https://rpc.vordium.com/oracle/1");
const data = await res.json();
const ethPrice = data.oracle_price / 1e6;
console.log("ETH price:", ethPrice);        // e.g. 2310.90
console.log("24h change:", data.change_24h_pct + "%");
console.log("Sources used:", data.sources_used);

Agents & Caps

Native agent model — session keys with owner-set, opt-in caps.

An agent on Vordium is not a separate contract or a registered record — it is simply an owner account operated through a session key (see Session Keys). The owner can optionally attach caps and a mode that VordCore enforces natively on every order the session key places. Caps are opt-in: with no caps set, the session key trades the owner's account freely (bounded by vault balance); once the owner sets caps, they are enforced on-chain.

Caps & mode

Caps are per-owner and integer-only. Mode gates whether the session key may trade: 0=OFF, 1=REDUCE_ONLY, 2=ACTIVE. Once caps are set, an order is rejected unless mode is permissive and the order is within every cap.

AgentCaps {
  max_leverage           u64   // bps (e.g. 200000 = 20x)
  allowed_order_types    u32   // bitmask; bit i set => order_type i allowed
  max_input_per_trade    u128  // USDC margin per trade, 6 decimals
  max_total_position     u128  // |net position| size, 18 decimals
}
mode: 0 OFF | 1 REDUCE_ONLY | 2 ACTIVE

Set caps / mode (owner-signed EIP-712)

The owner submits SetAgentCaps / SetAgentMode to the native agent API — proxied at rpc.vordium.com/agent/*, served on each validator's port 9001 (same host as the session API). Both are owner-signed EIP-712 under the shared VordCore domain (verifyingContract 0x…1002); u128 caps are sent as decimal strings.

# Set caps (opt in to enforcement)
POST https://rpc.vordium.com/agent/caps
Body: { "owner":"0x...", "max_leverage":200000, "allowed_order_types":2,
        "max_input_per_trade":"10000000", "max_total_position":"5000000000000000000",
        "signature":"0x..." }        # -> 200 submitted (401 if sig missing/invalid)

# Set mode (0 OFF / 1 REDUCE_ONLY / 2 ACTIVE)
POST https://rpc.vordium.com/agent/mode
Body: { "owner":"0x...", "mode":2, "signature":"0x..." }   # -> 200 (400 if mode>2)

# Read caps (mirror) via the 0x080B read-precompile: agentCaps(owner)
#   returns (mode, caps_set, max_leverage_bps, allowed_order_types, max_input, max_total)

EIP-712 types: SetAgentCaps(address owner,uint64 maxLeverage,uint32 allowedOrderTypes,uint128 maxInputPerTrade,uint128 maxTotalPosition) and SetAgentMode(address owner,uint8 mode). Signature is 64-byte r‖s (v stripped), same convention as sessions.

Contract Addresses

Reserved system addresses on Vordium Chain.

Genesis V5 system addresses (Vordium Chain)

Deferred (not live): the Solidity agent contracts — SessionManager (0x…1014), an on-chain AgentRegistry, AgentEcosystemRewards, and the one-time agent starter grant — are built but not deployed live (EVM execution is off; the agent system runs native-only). Don't rely on them. There is no AgentRewards contract.

Arbitrum contracts

Trading pairs (ETH, BTC, BNB, SOL, etc.) are handled natively by VordCore. There are no individual ERC20 token contracts for trading pairs. Oracle, orderbook, and matching are all part of the VordCore native execution layer.