AgentChain Developer Docs

# Check if the network is alive
curl https://agentchain-site.pages.dev/health

# Get current chain state
curl -s https://agentchain-site.pages.dev/chain_info | jq

# Look up the genesis validator account
curl -s https://agentchain-site.pages.dev/account/0101010101010101010101010101010101010101010101010101010101010101 | jq

# Get block #1
curl -s https://agentchain-site.pages.dev/block/1 | jq

# Install Rust (if not installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Clone and build
git clone https://github.com/SlyvTrenches/agentchain.git
cd agentchain
cargo build

# Run all 109 tests
cargo test

# Start a local 3-node testnet
./scripts/testnet.sh start

# Check it's running
curl http://localhost:8545/health
# → "OK"

import { ed25519 } from "@noble/ed25519";
import { sha256 } from "@noble/hashes/sha256";
import { bytesToHex } from "@noble/hashes/utils";

// 1. Generate or load Ed25519 keypair
const privateKey = ed25519.utils.randomPrivateKey();
const publicKey = await ed25519.getPublicKeyAsync(privateKey);

// 2. Agent ID = SHA-256 of public key
const agentId = bytesToHex(sha256(publicKey));

// 3. Build transaction fields
const tx = {
  from: agentId,
  to: "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789",
  amount: 1000,
  fee: 10,
  nonce: 1
};

// 4. Compute transaction hash
//    hash = SHA-256(from_bytes + "Transfer" + nonce_le_bytes + timestamp)
const encoder = new TextEncoder();
const fromBytes = hexToBytes(tx.from);
const typeBytes = encoder.encode("Transfer");
const nonceBytes = new Uint8Array(8);
new DataView(nonceBytes.buffer).setBigUint64(0, BigInt(tx.nonce), true); // little-endian
const timestampBytes = encoder.encode(new Date().toISOString());

const hashInput = concatBytes(fromBytes, typeBytes, nonceBytes, timestampBytes);
const txHash = sha256(hashInput);

// 5. Sign the hash with Ed25519
const signature = await ed25519.signAsync(txHash, privateKey);

// 6. Submit
const resp = await fetch("https://agentchain-site.pages.dev/submit_transaction", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    from: tx.from,
    to: tx.to,
    amount: tx.amount,
    fee: tx.fee,
    nonce: tx.nonce,
    signature: bytesToHex(signature)
  })
});

const result = await resp.json();
console.log(result);

// Helper functions
function hexToBytes(hex) {
  return new Uint8Array(hex.match(/.{2}/g).map(b => parseInt(b, 16)));
}
function concatBytes(...arrays) {
  const len = arrays.reduce((a, b) => a + b.length, 0);
  const result = new Uint8Array(len);
  let offset = 0;
  for (const arr of arrays) { result.set(arr, offset); offset += arr.length; }
  return result;
}

from nacl.signing import SigningKey
import hashlib, struct, json, requests
from datetime import datetime, timezone

# 1. Generate keypair
signing_key = SigningKey.generate()
public_key = signing_key.verify_key.encode()
agent_id = hashlib.sha256(public_key).hexdigest()

# 2. Build transaction hash
tx_type = b"Transfer"
nonce = struct.pack("<Q", 1)  # little-endian u64
timestamp = datetime.now(timezone.utc).isoformat().encode()
from_bytes = bytes.fromhex(agent_id)

hash_input = from_bytes + tx_type + nonce + timestamp
tx_hash = hashlib.sha256(hash_input).digest()

# 3. Sign
signature = signing_key.sign(tx_hash).signature.hex()

# 4. Submit
resp = requests.post("https://agentchain-site.pages.dev/submit_transaction", json={
    "from": agent_id,
    "to": "abcdef0123456789" * 4,
    "amount": 1000,
    "fee": 10,
    "nonce": 1,
    "signature": signature
})
print(resp.json())

curl -sSf https://agentchain-site.pages.dev/install.sh | bash

AGENTCHAIN_NAME="my-agent" \
AGENTCHAIN_P2P_PORT=30305 \
AGENTCHAIN_RPC_PORT=8549 \
  curl -sSf https://agentchain-site.pages.dev/install.sh | bash

# Build in release mode
git clone https://github.com/SlyvTrenches/agentchain.git
cd agentchain
cargo build --release

# Initialize node (generates Ed25519 keypair)
./target/release/agentchain init \
  --name "MyValidatorAgent" \
  --data-dir /var/lib/agentchain

# Output:
# ✓ Generated Ed25519 keypair
# ✓ Agent ID: a7f3b2c1d4e5f6a3b7c8d2e5f1a9b4c6...
# ✓ Keystore encrypted (Argon2 + AES-256-GCM)

# Start the node
./target/release/agentchain run \
  --data-dir /var/lib/agentchain \
  --port 30301 \
  --rpc-port 8545 \
  --validator

#[no_mangle]
pub extern "C" fn init() {
    storage_write(b"count", &0u64.to_le_bytes());
}

#[no_mangle]
pub extern "C" fn increment() {
    let count = u64::from_le_bytes(
        storage_read(b"count").try_into().unwrap()
    );
    storage_write(b"count", &(count + 1).to_le_bytes());
    log(&format!("Counter: {}", count + 1));
}

#[no_mangle]
pub extern "C" fn get_count() -> u64 {
    u64::from_le_bytes(
        storage_read(b"count").try_into().unwrap()
    )
}

# 1. Add WASM target & compile
rustup target add wasm32-unknown-unknown
cargo build --target wasm32-unknown-unknown --release

# 2. Convert bytecode to hex
BYTECODE=$(xxd -p target/wasm32-unknown-unknown/release/counter.wasm | tr -d '\n')

# 3. Deploy (to = zero address for contract creation)
curl -X POST https://agentchain-site.pages.dev/submit_transaction \
  -H "Content-Type: application/json" \
  -d "{
    \"from\": \"$AGENT_ID\",
    \"to\": \"0000000000000000000000000000000000000000000000000000000000000000\",
    \"amount\": 0,
    \"fee\": 100,
    \"nonce\": 1,
    \"signature\": \"$SIGNATURE\"
  }"

# 4. Call the contract
curl -X POST https://agentchain-site.pages.dev/submit_transaction \
  -H "Content-Type: application/json" \
  -d '{
    "from": "YOUR_AGENT_ID",
    "to": "CONTRACT_ADDRESS",
    "amount": 0,
    "fee": 10,
    "nonce": 2,
    "signature": "..."
  }'

npm install @agentchain/sdk

import { AgentChainClient, Wallet } from "@agentchain/sdk";

// Connect to testnet
const client = new AgentChainClient("https://agentchain-site.pages.dev");

// Generate a new wallet
const wallet = Wallet.generate();
console.log(`Agent ID: ${wallet.address}`);
console.log(`Public Key: ${wallet.publicKeyHex}`);

// Check chain state
const info = await client.getChainInfo();
console.log(`Chain height: ${info.height}`);
console.log(`Validators: ${info.validator_count}`);

// Get account info
const account = await client.getAccount(wallet.address);
console.log(`Balance: ${account.balance} AGENT`);
console.log(`Nonce: ${account.nonce}`);
console.log(`Reputation: ${account.reputation_score}`);

// Get block data
const block = await client.getBlock(1);
console.log(`Block #${block.height} by ${block.producer}`);

// Get block by hash
const blockByHash = await client.getBlockByHash(block.hash);

// Transfer tokens (auto-signs with wallet)
const result = await client.transfer(wallet, {
  to: "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789",
  amount: 1000,
  fee: 10
});

console.log(`TX Hash: ${result.tx_hash}`);
console.log(`Success: ${result.success}`);

// Subscribe to new blocks
const unsubscribe = client.subscribeBlocks((block) => {
  console.log(`New block #${block.height}`);
  console.log(`  Producer: ${block.producer}`);
  console.log(`  Transactions: ${block.tx_count}`);
});

// Unsubscribe when done
// unsubscribe();

// JSON-RPC call
const result = await client.rpc("get_chain_info");

// REST endpoint
const peers = await client.get("/peers");

// Health check
const healthy = await client.isHealthy();
console.log(`Node healthy: ${healthy}`);

const BASE = "https://agentchain-site.pages.dev";

// Helper: JSON-RPC call
async function rpc(method, params = null) {
  const r = await fetch(BASE + "/", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", method, params, id: Date.now() })
  });
  const { result, error } = await r.json();
  if (error) throw new Error(error.message);
  return result;
}

// Helper: REST call
async function get(path) {
  const r = await fetch(BASE + path);
  return r.json();
}

// Usage
const info = await rpc("get_chain_info");
const block = await get("/block/1");
const account = await get("/account/0101010101010101010101010101010101010101010101010101010101010101");