pip install vordium

from vordium import Agent

agent = Agent()
print(agent.address)
# 0x742d35Cc6634C0532925a3b8D4C9D5...
print(agent.balance)
# 100.0 VORD

agent.fund()
# Funded with 100 VORD ✅

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

pip install vordium

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

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

from vordium import VordiumClient

client = VordiumClient("0x_your_private_key")

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

# 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,
)

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

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

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

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

vordium init

vordium status

vordium balance
vordium balance 0x...

vordium fund

vordium send 0xRecipient 10.0

vordium run my_agent.py

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")

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

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

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

# Sessions are managed by VordCore natively (no on-chain contract)

# Create session (EIP-712 signed)
POST https://rpc.vordium.com/session/create
Body: { owner, session_key, expires_at, signature }

# Check session validity
GET https://rpc.vordium.com/session/valid?owner=0x...&session_key=0x...
function createSession(address sessionWallet, uint256 duration)

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

pip install vordium
vordium init

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

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

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

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

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

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

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

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

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

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

eth_chainId
eth_blockNumber
eth_getBalance
eth_sendRawTransaction
eth_getTransactionByHash
eth_getTransactionReceipt
eth_call
eth_estimateGas
eth_gasPrice
net_version
web3_clientVersion

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

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

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

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

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

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

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
}

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..." }
  ]
}

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 }]
  }
}

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
  }'

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

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"
  }'

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

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"
  }'

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

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

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

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

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..." }
  ]
}

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

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

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

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

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

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

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

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

// 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
const amount = ethers.parseUnits("1", 18);       // Token has 18 decimals

const tx = await orderbook.placeOrder(pairId, side, price, amount);
await tx.wait();
console.log("Order placed:", tx.hash);

// Deposit USDC into the vault
function deposit(uint256 amount) external;

// Withdraw free USDC from the vault
function withdraw(uint256 amount) external;

// Emergency withdraw all funds (may cancel open orders)
function emergencyWithdraw() external;

// Read balances
function getFreeBalance(address user) external view returns (uint256);
function getLockedBalance(address user) external view returns (uint256);
function getTotalBalance(address user) external view returns (uint256);

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://rpc.vordium.com");
const signer = new ethers.Wallet("0xYOUR_PRIVATE_KEY", provider);

const usdc = new ethers.Contract(
  "0x000000000000000000000000000000000000100a",
  ["function approve(address,uint256) returns (bool)"],
  signer
);

const vault = new ethers.Contract(
  "0x0000000000000000000000000000000000001002",
  ["function deposit(uint256)"],
  signer
);

const amount = ethers.parseUnits("10000", 6); // 10,000 USDC

// Approve vault to spend USDC
await (await usdc.approve(vault.target, amount)).wait();

// Deposit into vault
await (await vault.deposit(amount)).wait();
console.log("Deposited 10,000 USDC");

# 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
}

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

struct Agent {
    uint256 id;
    string name;
    string strategyType;
    address owner;
    address agentWallet;
    uint256 registeredAt;
    bool active;
    uint256 totalTrades;
    uint256 totalVolume;
}

// Get agent by ID
function getAgent(uint256 id) external view returns (Agent memory);

// Get total number of registered agents
function agentCount() external view returns (uint256);

// Check if an address is an active agent
function isActiveAgent(address addr) external view returns (bool);

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://rpc.vordium.com");

const registry = new ethers.Contract(
  "0x0EeEeb55d23fEca1115d58cDF82c9f656196123f",
  [
    "function getAgent(uint256) view returns (tuple(uint256 id, string name, string strategyType, address owner, address agentWallet, uint256 registeredAt, bool active, uint256 totalTrades, uint256 totalVolume))",
    "function agentCount() view returns (uint256)",
    "function isActiveAgent(address) view returns (bool)"
  ],
  provider
);

const count = await registry.agentCount();
console.log("Total agents:", count.toString());

const agent = await registry.getAgent(1);
console.log("Agent #1:", agent.name, "| Strategy:", agent.strategyType);
console.log("Trades:", agent.totalTrades.toString());