Datachain Rope Documentation

Introduction

Datachain Rope is a revolutionary distributed ledger protocol that replaces traditional blockchain architecture with a String Lattice structure inspired by DNA's double helix. Designed in 2018 and now production-ready, it provides:

• Sub-5 second finality with Byzantine fault tolerance
• Quantum-resistant cryptography using CRYSTALS-Dilithium3 and Kyber768
• AI Testimony validation for semantic and business logic verification
• Self-healing data with Reed-Solomon erasure coding
• GDPR compliance with controlled erasure protocol

Network Configuration

Mainnet

Testnet

Bootstrap Nodes

Running a Validator Node

# 1. Install rope-cli
cargo install rope-cli

# 2. Generate node keys (with post-quantum cryptography)
./rope keygen --quantum --output ~/.rope/keys

# 3. Get your Peer ID
./rope peer-id --key ~/.rope/keys/node.key --ip YOUR_IP --port 9000

# 4. Start a validator node on testnet
./rope node --network testnet --mode validator --data-dir ~/.rope/testnet

# Node will:
# - Connect to bootstrap nodes automatically
# - Produce anchor strings every ~4.2 seconds
# - Participate in Testimony consensus
# - Serve JSON-RPC on port 9001

String Lattice Architecture

The String Lattice is the foundational data structure of Datachain Rope, replacing traditional blockchain's linear chain with a multi-dimensional lattice inspired by DNA's double helix structure.

Key Properties

• Parallel Processing – Multiple strings can be processed simultaneously, unlike sequential blockchain blocks
• Intrinsic Ordering – Causally ordered events without global timestamps
• Efficient Consensus – Virtual voting based on visibility, no message overhead
• Self-Healing – Reed-Solomon erasure coding enables data recovery

String Structure

RopeString {
    id: StringId,               // Unique identifier (256-bit hash)
    creator: ValidatorId,       // Creating validator's public key
    timestamp: Timestamp,       // Logical timestamp (not wall clock)
    payload: Payload,           // Transaction data or testimony
    self_parent: Option<StringId>,   // Previous string from same creator
    other_parent: Option<StringId>,  // Latest string from other validator
    signature: Signature,       // Post-quantum signature (Dilithium3)
    nucleotide: Nucleotide,     // A, T, C, G – encodes string type
}

Nucleotide Types

AI Testimony System

AI Testimony is a unique validation layer where artificial intelligence agents provide semantic and business logic verification of transactions before they are finalized in the String Lattice.

Testimony Types

• Semantic Validation – Verifies that transaction data makes logical sense
• Business Logic – Ensures compliance with application-specific rules
• Anomaly Detection – Identifies unusual patterns that may indicate fraud
• Cross-Reference – Validates consistency with historical data

Testimony Structure

Testimony {
    string_id: StringId,        // String being validated
    validator: ValidatorId,     // AI validator identity
    verdict: Verdict,           // VALID, INVALID, or NEEDS_REVIEW
    confidence: f64,            // Confidence score (0.0 - 1.0)
    evidence: Vec<Evidence>,    // Supporting evidence
    timestamp: Timestamp,       // When testimony was created
    signature: Signature,       // Validator's signature
}

Validation Process

1. Transaction submitted to network
2. Assigned to AI testimony validators based on expertise
3. Validators analyze transaction semantics and business logic
4. Testimonies collected (minimum 2/3 supermajority required)
5. Transaction finalized or rejected based on aggregate verdict

OES Cryptography

OES (Observability, Erasability, Sovereignty) is Datachain Rope's cryptographic framework that ensures data can be observed by authorized parties, erased when required (GDPR compliance), and sovereignty remains with data owners.

Key Components

Controlled Erasure Protocol

Datachain Rope supports GDPR-compliant data erasure through a unique protocol that allows data to be permanently removed while maintaining network integrity:

• Erasure Request – Data owner initiates erasure
• Verification – Network verifies ownership and legal basis
• Controlled Erasure – Data shards are zeroed across all nodes
• Tombstone – Permanent record that data was lawfully erased

Consensus Mechanisms

Datachain Rope employs a multi-layer consensus architecture tailored to different organizational structures within the network. Each consensus mechanism is optimized for specific use cases.

Consensus Selection by Layer

Virtual Voting Algorithm

The Virtual Voting algorithm achieves consensus without explicit voting rounds by leveraging the String Lattice's gossip history:

fn determine_consensus(string: &RopeString, lattice: &StringLattice) -> bool {
    // Find validators who can "strongly see" this string
    let observers = lattice.find_strong_seers(string);
    
    // Calculate stake-weighted observation
    let observed_stake: u64 = observers.iter()
        .map(|v| v.stake)
        .sum();
    
    // Consensus achieved if 2/3+ of stake observes
    let total_stake = lattice.total_stake();
    observed_stake * 3 > total_stake * 2
}

// Strongly-sees: A string X strongly sees Y if:
// 1. X can see Y (Y is an ancestor of X)
// 2. X can see a supermajority of strings that can see Y

Byzantine Fault Tolerance

Datachain Rope maintains safety and liveness with up to f < n/3 Byzantine (malicious) validators:

• Safety – Two honest validators never finalize conflicting strings
• Liveness – Honest transactions eventually get finalized
• Asynchronous – No timing assumptions required

Federation Generation Protocol

The Federation Generation Protocol enables creation of structured organizational units within the Datachain Rope network. Each federation can contain multiple communities, data wallets, and individual chains.

Federation Types

Protocol Invocations

Federations can invoke multiple external protocols:

// Available Protocol Invocations
Datachain Rope // Native protocol (required)
Hyperledger    // Enterprise blockchain
XDC Network    // XinFin hybrid chain
Solana         // High-performance chain
Polkadot       // Cross-chain protocol
Bitcoin        // Store of value layer
Ethereum       // Smart contracts
Tangle         // IOTA DAG (coming soon)
Hashgraph      // Hedera consensus (coming soon)

Community Generation Protocol

Communities represent industry-specific or purpose-driven groups within the Datachain network. Each community has configurable KYC/AML requirements and AI-powered predictability features.

Industry Categories

Compliance Features

CLI Interface

The Datachain Rope CLI allows you to interact directly with the network from your terminal. Experience the original 2018 design through a modern command-line interface.

Installation

# Install via Cargo
cargo install rope-cli

# Or build from source
git clone https://github.com/KazeONGUENE/rope.git
cd rope/crates/rope-cli
cargo build --release

# Run the CLI
./target/release/rope-cli --rpc https://erpc.datachain.network

Configuration

# ~/.rope/config.toml

[network]
rpc_url = "https://erpc.datachain.network"
ws_url = "wss://ws.datachain.network"
chain_id = 271828

[wallet]
keystore_path = "~/.rope/keystore"
default_account = "0x..."

[crypto]
enable_pq_crypto = true    # CRYSTALS-Dilithium3 + Kyber768
oes_generation = 1         # OES evolution epoch

RPC API Reference

The Datachain Rope RPC API is available at https://erpc.datachain.network.

rope_networkStatus

Returns the current network status.

// Request
{
  "jsonrpc": "2.0",
  "method": "rope_networkStatus",
  "params": [],
  "id": 1
}

// Response
{
  "jsonrpc": "2.0",
  "result": {
    "status": "healthy",
    "finality_time_ms": 4200,
    "active_validators": 127,
    "ai_agents": 5,
    "latest_round": 847291,
    "total_strings": 1847293,
    "chain_id": 314159
  },
  "id": 1
}

rope_submitString

Submit a new string to the lattice.

// Request
{
  "jsonrpc": "2.0",
  "method": "rope_submitString",
  "params": [{
    "content": "0x...",
    "parents": ["0x...", "0x..."],
    "mutability_class": "immutable",
    "requires_testimony": true,
    "signature": "0x..."
  }],
  "id": 1
}

// Response
{
  "jsonrpc": "2.0",
  "result": {
    "string_id": "0x7a8b9c...",
    "round": 847292,
    "status": "pending_testimony"
  },
  "id": 1
}

Architecture Overview

┌─────────────────────────────────────────────────────────────────────────┐
│                    datachain.network (ROPE NETWORK)                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   CORE PROTOCOL (rope-node)                                             │
│   ─────────────────────────                                             │
│   • Post-Quantum Crypto (Dilithium3/Kyber768)       ✅ 100%             │
│   • Virtual Voting (Appendix B.1)                    ✅ 100%             │
│   • Reed-Solomon Erasure Coding                      ✅ 100%             │
│   • libp2p Transport (QUIC+TCP)                      ✅ 100%             │
│   • AI Testimony Validation                          ✅ 100%             │
│   • OES Cryptography                                 ✅ 100%             │
│   • Federation/Community Management                  ✅ 100%             │
│                                                                          │
│   NETWORK SERVICES                                                       │
│   ────────────────                                                       │
│   erpc.datachain.network  → JSON-RPC                                    │
│   ws.datachain.network    → WebSocket                                   │
│   faucet.datachain.network                                              │
│   bridge.datachain.network                                              │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘
                                │
                                │ Indexes & Fetches Data
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                      dcscan.io (BLOCK EXPLORER)                          │
│   • View Strings & Transactions                                         │
│   • Browse AI Agents & Testimonies                                      │
│   • Network Statistics & Charts                                         │
│   • Community Voting                                                    │
└─────────────────────────────────────────────────────────────────────────┘

Data Wallets — Datawallet+

Datawallet+ is the MetaMask of the Datachain Rope ecosystem — a self-custody identity and asset wallet for mobile (React Native / Expo) and web (React). It is the single entry point for sovereign identity, tokenized asset management, and cross-ecosystem interactions across Tanastok, DCSwap, NaturaProof, Careaway, Luzran, AlterOS, Picentriq, and Skywatcher.

Architecture Overview

┌──────────────────────────────────────────────────────────────────────────┐
│                         DATAWALLET+                                      │
│                                                                          │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌──────────────┐   │
│  │  Identity    │  │  Asset      │  │  DeFi       │  │  Fiat Ramp   │   │
│  │  Wallet      │  │  Manager    │  │  Hub        │  │  (Onramper)  │   │
│  │             │  │             │  │             │  │              │   │
│  │ ONCHAINID   │  │ DCNFT Deeds │  │ DCSwap      │  │ Buy/Sell     │   │
│  │ DID/SSDI    │  │ ERC-3643    │  │ LP Positions │  │ DC FAT       │   │
│  │ W3C VCs     │  │ DCR-20      │  │ Swap Router │  │ with fiat    │   │
│  │ ERC-735     │  │ Multi-chain │  │ Quotes      │  │              │   │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬───────┘   │
│         │                │                │                │            │
│  ┌──────┴────────────────┴────────────────┴────────────────┴───────┐    │
│  │              Core Services Layer                                │    │
│  │                                                                 │    │
│  │  NetworkService  │  MultiChainProvider  │  WalletConnectService │    │
│  │  RopeCrypto (Ed25519 + Dilithium3)  │  BiometricGate          │    │
│  │  IPFSService  │  EcosystemWebhooks  │  SecurityAuditService   │    │
│  └─────────────────────────────────────────────────────────────────┘    │
│         │                                                               │
│  ┌──────┴──────────────────────────────────────────────────────────┐    │
│  │              DatawalletConnect API v2.0                          │    │
│  │  WalletConnect v2 │ REST/SDK │ Ecosystem Connectors             │    │
│  └─────────────────────────────────────────────────────────────────┘    │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘
         │                    │                    │
         ▼                    ▼                    ▼
    Tanastok             DCSwap              NaturaProof
    Careaway             Luzran              AlterOS
    Picentriq            Skywatcher          Any dApp

DatawalletConnect SDK

@datawallet/connect is the official npm package for any dApp to add "Connect with Datawallet+" in one line. It uses WalletConnect v2 under the hood and supports all 4 chains (Rope, Ethereum, Polygon, XDC).

Installation

npm install @datawallet/connect @walletconnect/sign-client

Quick Start

import { DatawalletConnect } from '@datawallet/connect';

// Initialize
const dw = new DatawalletConnect({
  appName: 'My dApp',
  appUrl: 'https://mydapp.com',
});

// Connect — opens Datawallet+ via deep link or QR
const session = await dw.connect();
console.log(session.address);  // 0x...
console.log(session.chainId);  // 271828

// Sign a message
const signature = await dw.signMessage('Hello from My dApp');

// Send a transaction
const txHash = await dw.sendTransaction({
  to: '0x...',
  value: '1000000000000000000', // 1 FAT in wei
});

// Switch chain
await dw.switchChain(1); // Switch to Ethereum

// Disconnect
await dw.disconnect();

Datawallet+ Specific Methods

// Request user's DID and identity claims
const identity = await dw.getIdentity();
// { did: 'did:datachain:...', address: '0x...', claims: [...] }

// Request Datawallet+ to sign an ONCHAINID claim
const claim = await dw.signClaim({
  topic: 1,         // KYC_VALIDATED
  data: '0x...',
  uri: 'ipfs://...',
});

// Query wallet capabilities
const caps = await dw.getCapabilities();
// { onchainid: true, erc3643: true, ipfs: true, ... }

Events

dw.on('connect', (session) => { /* connected */ });
dw.on('disconnect', () => { /* disconnected */ });
dw.on('chainChanged', (chainId) => { /* chain switched */ });
dw.on('accountsChanged', (accounts) => { /* account switched */ });

Supported Chains

WalletConnect v2 Methods

Identity Wallet

Datawallet+ implements a full self-sovereign identity stack:

Claim Topics (ERC-735)

ONCHAINID Contracts (Mainnet)

Cryptography

Datawallet+ is the first mobile wallet with post-quantum resistance. Every signature is dual-signed with classical Ed25519 and post-quantum ML-DSA-65 (Dilithium3).

Key Derivation

Mnemonic (BIP-39, 12+ words)
  └─► BIP-32 seed
       └─► m/44'/60'/0'/0/0  →  secp256k1 private key  →  EVM address
            └─► SHA-256(privkey)  →  Ed25519 seed  →  DID keypair
                 └─► SHA-256(privkey + "Dilithium3 Seed")  →  ML-DSA-65 keypair

All keys are stored in expo-secure-store (iOS Keychain / Android Keystore). Sensitive operations are gated by biometric authentication (expo-local-authentication).

Asset Management

Domain Model: DCNFT → ERC-3643

Every real-world asset in the Datachain Rope ecosystem follows this model:

DCNFT (ERC-721)              ←  The DEED — minted once per asset
  │                               Originates from Tanastok, NaturaProof, or Datawallet+
  │
  ├─► ERC-3643 Contract A    ←  Fractional SHARES — minted per customer purchase
  │     tokenSymbol: "BFST"       maxSupply: 10,000 | mintedSupply: 3,247
  │
  └─► ERC-3643 Contract B    ←  Different tranche / jurisdiction
        tokenSymbol: "BFST-EU"    maxSupply: 5,000 | mintedSupply: 891

• DCNFT (ERC-721) = the asset deed, always minted first (title, metadata, provenance on IPFS)
• ERC-3643 tokens = fractional shares, minted each time a customer purchases. Supply grows with each acquisition.
• ERC-3643 transfers are compliance-gated: buyer must be verified in IdentityRegistry (KYC/AML claims on ONCHAINID)

Token Tiers (Display Priority)

Fiat On/Off Ramp

Non-crypto users can buy DC FAT directly in Datawallet+ with credit card or bank transfer through two providers:

Supported fiat currencies: USD, EUR, GBP, CHF, CAD, AUD, JPY, NGN, BRL, INR.
Supported crypto: DC FAT, ETH, MATIC, XDC, USDC, USDT.

Ecosystem Integration

Datawallet+ acts as the identity and asset hub for the entire Datachain Rope ecosystem. Events are broadcast via webhooks; data is shared through IPFS and on-chain state.

Webhook Events

When events occur in Datawallet+, signed webhooks notify ecosystem projects:

claim.issued          // ONCHAINID claim issued (KYC, AML, etc.)
claim.revoked         // Claim revoked
identity.created      // New DID / ONCHAINID deployed
identity.updated      // Identity claims updated
asset.registered      // New DCNFT deed registered
asset.transferred     // Asset ownership changed
credential.issued     // W3C Verifiable Credential issued
credential.presented  // Credential shared with a verifier
swap.executed         // DCSwap trade completed

IPFS Integration

All claim evidence, asset metadata, identity backups, and token lists are stored on IPFS via ecosystem-owned Kubo nodes. No centralized storage dependency.

Multi-Chain Support

While Datachain Rope is the primary chain, Datawallet+ provides real providers for Ethereum, Polygon, and XDC — users bring their entire portfolio into one wallet.

// Fetch balances across all chains
const balances = await multiChainProvider.getAllNativeBalances(address);
// [{ chain: 'Datachain Rope', native: '1250.5' }, { chain: 'Ethereum', native: '0.42' }, ...]

// Send on any chain
await multiChainProvider.sendNative(1, recipientAddress, '0.1'); // 0.1 ETH on Ethereum
await multiChainProvider.sendNative(271828, recipientAddress, '100'); // 100 FAT on Rope

Security

Pre-Audit Score

// Run from within Datawallet+
const report = await securityAuditService.runFullAudit();
// { score: 92, passCount: 13, failCount: 1, summary: '13/14 checks passed' }

Configuration

# .env — Required
EXPO_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
EXPO_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
EXPO_PUBLIC_WALLETCONNECT_PROJECT_ID=f4fbdb67d801061f152ec95eedaec338
EXPO_PUBLIC_INFURA_API_KEY=e350c5ccf8b044ff9158e7b30c8b0905

# IPFS — Ecosystem-owned nodes
EXPO_PUBLIC_IPFS_NODE_URL=http://localhost:5001
EXPO_PUBLIC_ROPE_IPFS_NODE_URL=https://ipfs.datachain.network

# Onramper — Fiat on/off ramp
EXPO_PUBLIC_ONRAMPER_API_KEY=pk_prod_...
EXPO_PUBLIC_ONRAMPER_SIGNING_SECRET=...

# DCSwap contracts (Datachain Rope mainnet)
EXPO_PUBLIC_DCSWAP_ROUTER_ADDRESS=0x8ebdd966e9e9af2ec5d02c886b1c4b5ba617e7c4
EXPO_PUBLIC_WFAT_ADDRESS=0x285eecf51d5f0a6ab8d8151139b4d19b05c6b3e4

DatawalletConnect API v2.0

The public API is exposed via DatawalletConnectAPI and consumable through WalletConnect v2 or the @datawallet/connect SDK.

Capabilities

const capabilities = await datawalletAPI.getCapabilities();
{
  version: '2.0.0',
  walletConnect: true,
  onchainid: true,
  erc3643: true,
  did: true,
  ssdi: true,
  ipfs: true,
  verifiableCredentials: true,
  selectiveDisclosure: true,
  privacyProofs: true,
  reputation: true,
  dataMonetization: true,
  universalAssetRegistry: true,
  crossChainIdentity: true,
  postQuantumSigning: true,
  fiatRamp: true,
  multiChain: true,
  supportedChains: [271828, 1, 137, 50],
  connectedEcosystemProjects: [
    'tanastok', 'dcswap', 'datachain_rope',
    'naturaproof', 'luzran', 'alteros',
    'picentriq', 'careaway', 'skywatcher'
  ]
}