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://engine.vordex.io";

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

SessionManager: 0xCbC7aD19B2dE08d710D498706A14F6c0c4F2b017

// Check if a session is valid
function isValidSession(address owner, address sessionWallet) → bool

// Register a new session (called by owner wallet)
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://ws.vordium.com");

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://api.vordex.io/health

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

curl https://api.vordex.io/v1/price/ETH

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

curl https://api.vordex.io/v1/price/all

curl "https://api.vordex.io/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://api.vordex.io/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://api.vordex.io/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://api.vordex.io/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://api.vordex.io/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://api.vordex.io/v1/order/42 \
  -H "Content-Type: application/json" \
  -d '{
    "trader": "0xYourAddress",
    "signature": "0xSignedMessage",
    "nonce": 1712678400,
    "network": "testnet"
  }'

curl -X DELETE https://api.vordex.io/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://api.vordex.io/v1/account/0xYourAddress?network=mainnet"

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

curl "https://api.vordex.io/v1/orders/0xYourAddress?network=mainnet"

curl "https://api.vordex.io/v1/fills/0xYourAddress?network=mainnet"

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

curl https://api.vordex.io/v1/agents

curl https://api.vordex.io/v1/agents/0xAgentAddress

curl https://api.vordex.io/v1/stats

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

curl "https://api.vordex.io/v1/leaderboard?type=agents"

curl https://api.vordex.io/v1/pairs

curl https://api.vordex.io/v1/network

// Place a limit order
function placeOrder(uint256 pairId, uint8 side, uint256 price, uint256 amount) external returns (uint256 orderId);

// Cancel an existing order
function cancelOrder(uint256 id) external;

// Place a market order with slippage protection
function placeMarketOrder(uint256 pairId, uint8 side, uint256 amount, uint256 worstPrice) external returns (uint256 orderId);

// Read functions
function getOrder(uint256 id) external view returns (Order memory);
function getTraderOrders(address trader) external view returns (uint256[] memory);
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);

import { ethers } from "ethers";

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

const orderbook = new ethers.Contract(
  "0x206816A711257be4F232c9A03dF70e46B02c046B",
  ["function placeOrder(uint256,uint8,uint256,uint256) returns (uint256)"],
  signer
);

// Buy 1 ETH at $3200 USDC
const pairId = 1;  // ETH
const side = 0;    // Buy
const price = ethers.parseUnits("3200", 6);     // USDC has 6 decimals
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(
  "0xc7fBc4a0A05Ad597C9cFed19e55bb8F5bEFcFD04",
  ["function approve(address,uint256) returns (bool)"],
  signer
);

const vault = new ethers.Contract(
  "0x20fE8c302AC2a17132bF6cc9E8FE09c9D8E6904f",
  ["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 the current spot price (18 decimals)
function getSpotPrice(uint256 pairId) external view returns (uint256);

// Get the TWAP over a given period in seconds
function getTWAP(uint256 pairId, uint256 period) external view returns (uint256);

import { ethers } from "ethers";

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

const oracle = new ethers.Contract(
  "0x33751B43995A5D02E60De66a43D3AD0609eFb83A",
  [
    "function getSpotPrice(uint256) view returns (uint256)",
    "function getTWAP(uint256,uint256) view returns (uint256)"
  ],
  provider
);

// Get ETH spot price (pairId = 1)
const spotPrice = await oracle.getSpotPrice(1);
console.log("ETH price:", ethers.formatUnits(spotPrice, 18));

// Get ETH 1-hour TWAP
const twap = await oracle.getTWAP(1, 3600);
console.log("ETH 1h TWAP:", ethers.formatUnits(twap, 18));

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