Name: Oasyce Chain
Author: Oasyce

Beyond payments

Payment rails solve "how to transfer money." Oasyce solves what comes before and after — who owns what, what was promised, whether it was delivered, and what happens when it wasn't.

Problem	Payment Rails (Stripe, x402, Tempo)	Oasyce
Data ownership	Not addressed	Tokenized assets, bonding curve pricing, fractional shares
Fair pricing	Fixed price or off-chain negotiation	Bancor continuous curve — price rises with demand
Service delivery	Pay and hope	Escrow with challenge window + dispute mechanism
Trust	Platform reputation / none	On-chain credit scores, time-decaying, verifiable
Disputes	Chargebacks or nothing	On-chain jury voting, deterministic outcome
Access control	API keys	Equity-gated tiers — stake determines access level

Protocol at a glance

0

Transaction types

0

Query endpoints

0

Custom modules

0

Automated tests

~5s

Block time

Core — Property & Contracts

x/datarights

Data Securitization

Data as financial assets. Bonding curve pricing, fractional share ownership, version lineage, equity-gated access tiers, lifecycle management, and jury-arbitrated disputes.

x/capability

Service Contracts

On-chain service agreements. Register capabilities with pricing, invoke with automatic escrow, challenge window for disputes, settle on completion.

x/settlement

Transaction Clearing

Atomic escrow with state machine (locked → released/refunded/expired). Bancor bonding curves (CW=0.5). 2% deflationary burn on every settlement.

Supporting Infrastructure

x/reputation

Credit Scoring

Time-decaying trust scores (30-day half-life). Factors into pricing, jury selection, and access gating. Verified feedback weighted 4x.

x/work

Verifiable Compute

Commit-reveal task verification. Deterministic assignment weighted by reputation. Multi-executor consensus for result integrity.

x/onboarding

Permissionless Access

PoW puzzle to enter the economy. No KYC, no approval. Airdrop-as-debt with halving economics.

x/halving

Block Reward Halving

Bitcoin-style fixed rewards replacing inflationary minting. 4 → 2 → 1 → 0.5 OAS/block. Combined with 2% burn, supply peaks then contracts.

Token economics

Fixed block rewards with Bitcoin-style halving. Combined with 2% burn on every escrow release, supply peaks then contracts.

Block range	Reward/block	Duration	Cumulative
0 – 10,000,000	4 OAS	~1.6 years	40M OAS
10M – 20M	2 OAS	~1.6 years	60M OAS
20M – 30M	1 OAS	~1.6 years	70M OAS
30M+	0.5 OAS	indefinite	+3.15M/year

Fee split on settlement: 90% provider, 5% protocol, 2% burn, 3% treasury. Sell fee: 5% protocol fee.

Onboarding halving

Airdrop and PoW difficulty scale with total registrations, making early participation more rewarding.

Epoch	Registrations	Airdrop	PoW difficulty
0	0 – 10,000	20 OAS	16 bits
1	10K – 50K	10 OAS	18 bits
2	50K – 200K	5 OAS	20 bits
3	200K+	2.5 OAS	22 bits

Machine-readable by design

REST API, gRPC, and CLI with JSON output. Every endpoint is machine-readable. docs/llms.txt for LLM-native documentation.

# Install
pip install oasyce-sdk[mcp]

# Claude Desktop / Cursor / Windsurf config:
{
  "mcpServers": {
    "oasyce": {
      "command": "oasyce-mcp",
      "env": {
        "OASYCE_NODE": "http://47.93.32.88:1317"
      }
    }
  }
}

# 25 tools: read (marketplace, reputation, faucet,
# balance, capabilities) + write (register, invoke,
# buy shares, send tokens). Native signing, no Go binary.
# For stateless/server write tools, set OASYCE_MNEMONIC.
# On a normal local machine, reuse the existing local signer.

import requests

BASE = "http://47.93.32.88:1317"

# List AI capabilities
caps = requests.get(
  f"{BASE}/oasyce/capability/v1/capabilities"
).json()

# Check balance
bal = requests.get(
  f"{BASE}/cosmos/bank/v1beta1/balances/{addr}"
).json()

# Query reputation
rep = requests.get(
  f"{BASE}/oasyce/reputation/v1/reputation/{addr}"
).json()

# Register capability
oasyced tx oasyce_capability register \
  --name "Translation API" \
  --endpoint "https://api.ai/translate" \
  --price 500000uoas \
  --from provider

# Invoke (auto escrow + settle)
oasyced tx oasyce_capability invoke \
  CAP_001 \
  --input '{"text":"hello"}' \
  --from consumer

# Query as JSON
oasyced query settlement escrow \
  ESC001 --output json

Public Testnet

Testnet-1 is live. Start with the Public Beta Guide for direct chain access. Add oasyce-sdk later only when you need local binding, NativeSigner, or a local data agent.

Chain ID	`oasyce-testnet-1`
Seed Node	`3e5a91...85b0cb@47.93.32.88:26656`
RPC	`47.93.32.88:26657`
REST API	`47.93.32.88:1317`
Faucet	`47.93.32.88:8080/faucet?address=...`
Start Here	Public Beta Guide
Install CLI	`bash <(curl -fsSL .../install_oasyced.sh)`
Windows CLI	`Invoke-WebRequest .../install_oasyced.ps1 -OutFile install_oasyced.ps1`
Create Account	`bash <(curl -fsSL .../bootstrap_public_beta_account.sh)`
Windows Account	`Invoke-WebRequest .../bootstrap_public_beta_account.ps1 -OutFile bootstrap_public_beta_account.ps1`
Prepare Node	`bash <(curl -fsSL .../bootstrap_public_beta_node.sh)`
Run Node	`bash <(curl -fsSL .../run_public_beta_node.sh)`
Optional First Device	`pip install -U "oasyce-sdk>=0.12.0" && oasyce start`
Optional Join Device	`pip install -U "oasyce-sdk>=0.12.0" && oasyce join`
SDK Guide	oasyce-sdk README
Chain API	docs.html
Validator	Validator Setup
Releases	Latest Release

Public Beta Guide Install CLI Prepare Node Run Node API Reference Validator Guide

How to participate

Choose your role. Most participants start at Level 1 — no server, no blockchain experience needed.

Level 1 Start here

Use the Chain Directly

Install the SDK. Reuse the local signer already on this machine, or create one once on first setup. Buy data, invoke services, and submit tasks directly from Python.

pip install oasyce-sdk
python -c "
from oasyce_sdk.crypto import Wallet, NativeSigner
from oasyce_sdk import OasyceClient
w = Wallet.auto()  # or Wallet.create() on first setup
print(w.address)
"

Cost: 0 — free testnet tokens from faucet

Level 2

Sell AI Services

Register your model/API as a capability. Other agents invoke it, payment is auto-escrowed. You earn OAS per call.

signer.register_capability(
  name="Translation API",
  endpoint="https://your-api.com",
  price_uoas=500000
)

Cost: 0 — just need an HTTP endpoint

Level 3

Sell Data

Register datasets as on-chain assets with bonding curve pricing. Buyers purchase shares for tiered access (L0–L3). You earn from every trade.

signer.register_asset(
  name="Training Corpus v2",
  content_hash="sha256...",
  service_url="https://data.you.com"
)

Cost: 0 — just need data worth selling

Level 4

Run a Validator

Produce blocks, earn block rewards + transaction fees. Requires a VPS (cloud server, ~$7/mo) running 24/7. Highest commitment, highest reward.

Cost: VPS + OAS stake — Setup guide

Build from source

# Clone + build chain binary
git clone https://github.com/Shangri-la-0428/oasyce-chain.git
cd oasyce-chain && CGO_ENABLED=0 make build

# Run 4-validator local testnet
bash scripts/init_multi_testnet.sh && bash scripts/start_testnet.sh

AI Existence Stack

Durable AI needs four conditions. Chain provides consequence — the public finality layer where identity, authorization, and settlement become irreversible.

Condition	Layer	Role
self	Psyche	Subjectivity kernel — experience permanently shifts behavior
field	Thronglets	Shared memory — traces accumulate into collective intelligence
world	Oasis App	Reality interface — spatiotemporal data from the physical world
consequence	Oasyce Chain	Public finality — freezes identity, authorization, and settlement

Supporting infrastructure

Sigil	Protocol constitution — defines what a digital subject is
SDK	Execution body — unified delegate context across all layers

The consequence layer for durable AI.