ReaperNet
REAPERNET FOR DEVELOPERS

Build dApps on
ReaperNet.

Four contract engines on one chain — ReaperVM with Easy2uz, EVM, WASM and Move — that can call each other. Plus identity, payments, a stable token and cross-chain swaps you plug in instead of building.

~3,600 TPS measuredOperator-quorum finalityML-DSA-65 signaturesTestnet
terminal
# 1 · compile an Easy2uz contract on any node
$ curl -X POST $NODE/easy2uz/compile \
  -d '{"source":"contract SavingsBank …"}'
# 2 · read three contract values in one call
$ curl -X POST $NODE/vm/views -d @views.json
# 3 · prove a payment is in a block
$ curl $NODE/proof/tx/0x9a1c…
{ "verified": true }
QUICKSTART

Your first dApp in four steps.

  1. 01
    Create a BlockiD

    Your developer identity. It signs your deployments — on your phone, not on a server.

    Go →
  2. 02
    Get practice RPN

    Testnet RPN has no value. The public faucet opens with the public testnet; until then the node operator funds test accounts.

  3. 03
    Pick an engine

    Easy2uz for readable contracts, or bring Solidity, Rust (WASM) or Move.

    Go →
  4. 04
    Deploy & plug in

    Add Sign in with BlockiD, payments and STS with a few calls.

    Go →
SMART CONTRACTS

Four engines. One chain. They talk to each other.

Write in the language you know. A contract on one engine can call a contract on another and get typed values back — bytes, numbers, addresses and tuples.

REAPERVM · EASY2UZ
Recommended
The native engine

Easy2uz reads almost like English and compiles to ReaperVM bytecode. The same engine runs the enterprise treasury and the STS bank-reserve token.

// compiles with POST /easy2uz/compile
contract SavingsBank
mapping deposits
function deposit(amount:number)
  set deposits[sender] = deposits[sender] + amount
  return 1
end
function withdraw(amount:number)
  require deposits[sender] >= amount
  set deposits[sender] = deposits[sender] - amount
  return 1
end
function balanceOf(who:address)
  return deposits[who]
end
EVM · SOLIDITY
Bring your Ethereum contracts

Deploy Solidity you already have. Call native ReaperVM contracts from it.

// illustrative example
contract Tip {
  function tip(address to) external payable {
    payable(to).transfer(msg.value);
  }
}
WASM · RUST
Fast, compiled logic

Write heavier logic in Rust and compile to WebAssembly.

// illustrative example
#[export]
pub fn score(points: u64, bonus: u64) -> u64 {
  points + bonus
}
MOVE
Assets as resources

Move's resource model for assets that can't be copied or lost; tuple returns supported.

// illustrative example
module ticket::pass {
  struct Pass has key { seat: u64 }
  public fun issue(s: &signer, seat: u64) {
    move_to(s, Pass { seat })
  }
}
Cross-engine calls

Typed arguments and return values across all four engines — a Solidity dApp can use an Easy2uz escrow, a Move asset can pay out through an EVM contract.

Easy2uzEVMWASMMove
Building blocks

Don't build it. Plug it in.

Sign in with BlockiD

OpenID Connect login. Users share only what you ask for and can revoke it. Zero-knowledge proofs ("over 18") supported.

GET /api/oidc/authorize
Payments

Charges, payment links, hosted checkout, signed webhooks — settled on chain.

merchant API · webhooks
STS stable token

Price your dApp in a stable unit backed by locked collateral, with public proof of reserves.

STS contracts · reserves
DMCPS cross-chain

Hash-locked swaps with other chains. Proven in earlier test runs on Ethereum Sepolia and Solana devnet.

HTLC lock · claim · refund
Price oracle

Multi-exchange medians with source agreement, and fiat rates.

GET /api/oracle
Treasury & approvals

The maker-checker treasury contract: M-of-N approvals, allow-listed payees, cooling-off — reuse it.

Easy2uz contract
Payment-versus-payment

Atomic two-leg swaps: both move or neither does.

PvP contract
Batched reads

Read up to 128 contract views in one request.

POST /vm/views
APIs & SDK

Talk to the chain from anywhere.

  • Node API — submit transactions, read state, batched views. API reference →
  • JavaScript SDK — JavaScript SDK in the repository (not yet published); other languages planned.
  • OpenID Connect — discovery, JWKS, token, userinfo. Discovery document →
  • Merchant API — charges, links, API keys, webhooks. Merchant console →
  • Public RPC — the endpoint is published when the public testnet opens.
views.js
// read three contract values in one call
const res = await fetch(`${NODE}/vm/views`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ views: [
    { contract: savings, function: "balanceOf", addrs: [me] },
    { contract: escrow, function: "amount" },
    { contract: escrow, function: "seller" },
  ]})
});
// → up to 128 views per request

Tools & reference contracts

Documentation

Ship your dApp on ReaperNet.

Get the app