KXCO Armature — User Guide

1. Network Overview

KXCO Armature is a private, permissioned blockchain built on Hyperledger Besu v26.4.0 using the QBFT (Quorum Byzantine Fault Tolerant) consensus protocol. It is operated by Knightsbridge Group as a high-performance settlement and tokenisation layer for institutional participants.

Why QBFT?

QBFT provides Byzantine fault tolerance with deterministic, instant finality. Blocks are final the moment they are sealed — there are no forks and no probabilistic confirmations. This makes KXCO Armature suitable for regulated financial workflows where settlement certainty is required.

2. Using the Block Explorer

The explorer gives a real-time view of the chain. Use the search bar at the top to look up any block number, transaction hash, or address.

3. Network Integration

KXCO Armature exposes a standard Ethereum JSON-RPC interface (EIP-1474). Any tool that speaks JSON-RPC over HTTP or WebSocket is compatible. The network parameters required by every integration method are:

Direct JSON-RPC (HTTP)

The lowest-level integration — suitable for server-side applications, internal services, and languages without a dedicated web3 library.

# Check chain ID (verify you are connected to KXCO Armature)
curl -s -X POST https://chain.kxco.ai/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'
# → {"result":"0x457"}  (0x457 = 1111 decimal)

# Latest block number
curl -s -X POST https://chain.kxco.ai/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Account balance (in wei)
curl -s -X POST https://chain.kxco.ai/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0xYOUR_ADDRESS","latest"],"id":1}'

# Send raw signed transaction
curl -s -X POST https://chain.kxco.ai/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":["0xSIGNED_TX_HEX"],"id":1}'

ethers.js (JavaScript / TypeScript)

import { ethers } from "ethers";

// HTTP provider
const provider = new ethers.JsonRpcProvider("https://chain.kxco.ai/rpc");

// Verify chain
const network = await provider.getNetwork();
console.log(network.chainId); // 1111n

// WebSocket provider (real-time events)
const wsProvider = new ethers.WebSocketProvider("wss://chain.kxco.ai/rpc");
wsProvider.on("block", n => console.log("New block:", n));

// Send a transaction (requires a funded private key)
const wallet = new ethers.Wallet("0xYOUR_PRIVATE_KEY", provider);
const tx = await wallet.sendTransaction({
  to:    "0xRECIPIENT",
  value: ethers.parseEther("1.0"),
});
const receipt = await tx.wait();
console.log("Confirmed in block:", receipt.blockNumber);

viem (TypeScript-first)

import { createPublicClient, createWalletClient, http, defineChain } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const kxcoChain = defineChain({
  id:   1111,
  name: "KXCO Armature",
  nativeCurrency: { name: "ARMR", symbol: "ARMR", decimals: 18 },
  rpcUrls: { default: { http: ["https://chain.kxco.ai/rpc"], webSocket: ["wss://chain.kxco.ai/rpc"] } },
});

const publicClient = createPublicClient({ chain: kxcoChain, transport: http() });

const blockNumber = await publicClient.getBlockNumber();
console.log("Block:", blockNumber);

// Write client
const account = privateKeyToAccount("0xYOUR_PRIVATE_KEY");
const walletClient = createWalletClient({ account, chain: kxcoChain, transport: http() });
const hash = await walletClient.sendTransaction({ to: "0xRECIPIENT", value: 1_000_000_000_000_000_000n });

web3.py (Python)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://chain.kxco.ai/rpc"))

# Verify connection
assert w3.is_connected(), "RPC not reachable"
assert w3.eth.chain_id == 1111, "Wrong chain"

# Read
block = w3.eth.get_block("latest")
print("Block:", block.number)

balance = w3.eth.get_balance("0xYOUR_ADDRESS")
print("Balance (ARMR):", w3.from_wei(balance, "ether"))

# Send transaction
signed = w3.eth.account.sign_transaction({
    "to":       "0xRECIPIENT",
    "value":    w3.to_wei(1, "ether"),
    "gas":      21000,
    "gasPrice": 0,
    "nonce":    w3.eth.get_transaction_count("0xYOUR_ADDRESS"),
    "chainId":  1111,
}, private_key="0xYOUR_PRIVATE_KEY")
tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)
receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

Browser Wallets (MetaMask, Rabby)

For development, testing, or web-based dApp integration. Add KXCO Armature as a custom network:

await window.ethereum.request({
  method: "wallet_addEthereumChain",
  params: [{
    chainId:         "0x457",
    chainName:       "KXCO Armature",
    nativeCurrency:  { name:"ARMR", symbol:"ARMR", decimals:18 },
    rpcUrls:         ["https://chain.kxco.ai/rpc"],
    blockExplorerUrls: ["https://chain.kxco.ai/explorer"],
  }],
});

Enterprise Integration

For institutional deployments — Hyperledger Firefly, EVM-compatible custody platforms (Fireblocks, Anchorage, Copper), or custom settlement infrastructure — connect to the observer node JSON-RPC endpoint using the network parameters above. KXCO Armature is EIP-1559 compatible and supports the full standard Ethereum JSON-RPC namespace (eth_, net_, web3_).

4. RPC & API Endpoints

Each node exposes a standard Ethereum JSON-RPC interface compatible with all web3 tooling.

Example calls

# Current block number
curl -s -X POST https://chain.kxco.ai/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Current validator set (validator RPC — localhost only)
curl -s -X POST http://localhost:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"qbft_getValidatorsByBlockNumber","params":["latest"],"id":1}'

WebSocket subscriptions

// Subscribe to new block headers (ethers.js)
const provider = new ethers.providers.WebSocketProvider("wss://chain.kxco.ai/rpc");
provider.on("block", blockNumber => console.log("New block:", blockNumber));

5. Sending Transactions

Via ethers.js

import { ethers } from "ethers";

const provider = new ethers.providers.JsonRpcProvider("http://<host>:8545");
const wallet = new ethers.Wallet("0xYOUR_PRIVATE_KEY", provider);

const tx = await wallet.sendTransaction({
  to: "0xRECIPIENT_ADDRESS",
  value: ethers.utils.parseEther("1.0"),
});
await tx.wait();
console.log("Confirmed in block:", tx.blockNumber);

Gas on KXCO Armature

KXCO Armature uses EIP-1559 gas mechanics. The current base fee is 0, meaning transactions cost zero gas. Always set a non-zero gas limit (21000 for plain transfers).

6. Smart Contracts

KXCO Armature is fully EVM-compatible. Hardhat, Foundry, and Truffle work out of the box — set chainId: 1111.

// hardhat.config.js
networks: {
  kxco: {
    url: "http://<host>:8545",
    chainId: 1111,
    accounts: ["0xYOUR_PRIVATE_KEY"],
  },
}

All Solidity versions targeting ^0.8.20+ are fully compatible, including contracts using PUSH0.

7. Validators & Consensus

QBFT requires a supermajority (>⅔) of validators to agree on each block. With 4 validators the network can tolerate 1 faulty node.

How is block finality guaranteed?

QBFT produces deterministic finality. Once a block receives signatures from ⅔+1 validators it is irreversible — there is no concept of “confirmations” or reorg risk.

8. Node Architecture

The network runs four Hyperledger Besu nodes connected via a static peer list. Discovery is disabled — peers are configured explicitly.

┌─────────────────────────────────────────────────────┐
│                   KXCO Armature Network                │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐        │
│  │  node1   │◄─►│  node2   │◄─►│  node3   │        │
│  │ validator│   │ validator│   │ validator│        │
│  └────┬─────┘   └────┬─────┘   └────┬─────┘        │
│       └──────────────┼──────────────┘               │
│                      ├─────────────────────────────►│
│                      ▼                  ┌────────┐  │
│              ┌──────────────┐           │ node4  │  │
│              │   observer   │           │  val.  │  │
│              │  (read-only) │           └────────┘  │
│              └──────────────┘                      │
└─────────────────────────────────────────────────────┘

9. Frequently Asked Questions