WASM Smart Contracts

RougeChain includes a built-in WASM smart contract engine powered by wasmi — the same pure-Rust WASM interpreter used by Parity/Substrate.

Overview

Contracts are written in Rust (or any language that compiles to WASM), compiled to .wasm, and deployed on-chain. Execution is fuel-metered in a sandbox with host functions for chain interaction.

Architecture

Your Contract (Rust) → cargo build --target wasm32
  → .wasm bytecode
    → Deploy via API
      → Execute in wasmi sandbox
        → Host functions bridge to chain state

Host Functions

Contracts can call these host functions to interact with the chain:

Gas Metering & Fees

Every WASM instruction costs 1 fuel unit. The default limit is 10,000,000 fuel per call (≈10M instructions). If a contract runs out of fuel, execution halts and all state changes are reverted.

Fee Schedule

Fees are automatically calculated and included in the on-chain transaction. They appear in the transaction detail view on the explorer.

API

Deploy a Contract

POST /api/v2/contract/deploy
{
  "wasm": "<base64-encoded WASM bytecode>",
  "deployer": "<public key hex>",
  "nonce": 0
}

Call a Contract Method

POST /api/v2/contract/call
{
  "contractAddr": "<contract address>",
  "method": "my_method",
  "caller": "<public key>",
  "args": { "key": "value" },
  "gasLimit": 10000000
}

Query Contract State

GET /api/contract/{addr}                # metadata
GET /api/contract/{addr}/state          # full state dump (all keys)
GET /api/contract/{addr}/state?key=x    # single key lookup
GET /api/contract/{addr}/events         # event log
GET /api/contracts                      # list all contracts

ERC-20 Token Standard

RougeChain includes a reference ERC-20 token contract at contracts/erc20_template/. This implements the standard fungible token interface:

Storage Layout

• meta:name / meta:symbol / meta:decimals / meta:total_supply — Token metadata
• bal:{account} — Account balances
• allow:{owner}:{spender} — Allowances

Build & Deploy

cd contracts/erc20_template
cargo build --release --target wasm32-unknown-unknown
# Deploy the .wasm from target/wasm32-unknown-unknown/release/

Explorer Integration

Deployed contracts are visible in the RougeChain explorer:

• Contracts Explorer (/contracts) — List all deployed contracts with search/sort
• Contract Detail (/contract/{addr}) — Contract info, live state viewer, interactive call UI
• Transaction Detail — Contract txs show: contract address, method, gas used, WASM size

SDK

import { RougeChain } from '@rougechain/sdk';

const rc = new RougeChain({ baseUrl: 'https://rougechain.io' });

// Deploy
const deploy = await rc.deployContract({
  wasm: base64WasmBytes,
  deployer: wallet.publicKey,
});

// Call
const result = await rc.callContract({
  contractAddr: deploy.address,
  method: 'increment',
  caller: wallet.publicKey,
});

// Query
const meta = await rc.getContract(deploy.address);
const events = await rc.getContractEvents(deploy.address);
const allState = await rc.getContractState(deploy.address);         // full dump
const single = await rc.getContractState(deploy.address, '636f756e74'); // single key

MCP Server (AI Agents)

The RougeChain MCP server exposes smart contract operations as tools for AI agents:

Security

WASM smart contracts maintain RougeChain's post-quantum security guarantees:

• All contract interactions are ML-DSA-65 signed transactions
• WASM execution is pure computation — no classical crypto involved
• Contract addresses are derived deterministically via SHA-256
• Execution is sandboxed with no host OS access

Cross-Contract Calls

Contracts can call other contracts using host functions. Calls are queued during execution and processed recursively by the runtime after the primary call completes.

Host Functions

Behavior

• Max depth: 8 nested calls (prevents infinite recursion)
• State merging: storage writes, events, and balance deltas from sub-calls are merged atomically
• Gas: sub-calls consume gas from the parent's remaining budget
• Failure: if a sub-call fails, it returns -2 from host_get_call_result; the parent can handle it gracefully

Example (Rust)

#![allow(unused)]
fn main() {
extern "C" {
    fn host_call_contract(
        addr: *const u8, alen: u32,
        method: *const u8, mlen: u32,
        args: *const u8, argslen: u32,
        gas: u64,
    ) -> i32;
    fn host_get_call_result(call_id: i32, buf: *mut u8, len: u32) -> i32;
}

#[no_mangle]
pub extern "C" fn call_other() {
    let addr = b"contract_abc123...";
    let method = b"get_value";
    let args = b"{}";
    let call_id = unsafe {
        host_call_contract(
            addr.as_ptr(), addr.len() as u32,
            method.as_ptr(), method.len() as u32,
            args.as_ptr(), args.len() as u32,
            1_000_000,
        )
    };
    // Result is available after host processes the call queue
    let mut buf = [0u8; 1024];
    let n = unsafe { host_get_call_result(call_id, buf.as_mut_ptr(), buf.len() as u32) };
    // n > 0: success, n bytes of return data
    // n == -2: sub-call failed
}
}

PQC Precompiles

Native post-quantum cryptographic operations available as host functions — no need to implement ML-DSA in WASM.

Key Sizes

• Public Key: 1,952 bytes (ML-DSA-65)
• Signature: 3,309 bytes (ML-DSA-65)
• Address: ~63 bytes (rouge1... bech32m string)
• Pubkey Hash: 32 bytes (SHA-256)

Use Cases

• On-chain auth: Verify a user's PQC signature inside a contract
• Address derivation: Convert a pubkey to a rouge1... address for permission checks
• Identity checks: Compare pubkey hashes for compact storage

EIP-1559 Dynamic Fees

RougeChain uses an EIP-1559-like fee model with base fee adjustment and fee burning:

How It Works

1. Base fee adjusts ±12.5% per block based on block fullness (target: 10 txs/block)
2. Floor: minimum base fee of 0.001 XRGE
3. Fee burning: base fee portion is burned (deflationary)
4. Priority fee (tip): 20% to block proposer, 70% to validators (stake-weighted), 10% to treasury

API

GET /api/fee-info

{
  "baseFee": 0.0377,
  "suggestedPriorityFee": 0.0038,
  "suggestedTotalFee": 0.0415,
  "totalBurned": 68.16,
  "targetTxsPerBlock": 10,
  "maxChangePercent": 12.5,
  "blockHeight": 618
}