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

Quick Start

Everything you need to make your first request against Datachain Rope mainnet in under 5 minutes.

1. Add Datachain Rope to your wallet

MetaMask, Rabby, and any EIP-3085-compatible wallet can add the network programmatically:

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [{
    chainId: '0x425D4',                              // 271828
    chainName: 'Datachain Rope',
    nativeCurrency: { name: 'DC FAT', symbol: 'FAT', decimals: 18 },
    rpcUrls: ['https://erpc.datachain.network'],
    blockExplorerUrls: ['https://dcscan.io']
  }]
});

2. Make your first RPC call

The public JSON-RPC endpoint serves both the canonical rope_* namespace and the eth_* compatibility aliases — ethers.js, viem, web3.js, and Foundry cast work out of the box:

# Current knot index (EVM alias: eth_blockNumber)
curl -s https://erpc.datachain.network \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"rope_knotIndex","params":[],"id":1}'

# Network-wide Quipu registry stats
curl -s https://erpc.datachain.network \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"rope_globalStats","params":[],"id":1}'

3. Query the REST API

DCScan exposes a public REST API for indexed data — stats, strings, transactions, validators, AI agents, and the entity registry. No key is required for casual use; identified traffic with an API key gets attribution and usage metrics:

curl -s https://dcscan.io/api/v1/stats
curl -s -H "X-API-Key: dcsk_…" https://dcscan.io/api/v1/strings/latest

4. Get an API key

Sign in with your Datawallet+ account or an EIP-191 wallet signature in the API Keys section below, then create and manage keys directly from this page.

5. Read from a contract

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://erpc.datachain.network', {
  chainId: 271828, name: 'datachain-rope'
});

const WFAT = '0x285eecf51d5f0a6ab8d8151139b4d19b05c6b3e4';
const dcr20 = new ethers.Contract(WFAT, [
  'function name() view returns (string)',
  'function symbol() view returns (string)',
  'function totalSupply() view returns (uint256)'
], provider);

console.log(await dcr20.name());        // "Wrapped DC FAT"
console.log(await dcr20.symbol());      // "WFAT"

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 — rope

The rope CLI is the canonical operator tool for Datachain Rope. It runs nodes, queries chain state, manages deployer identity, exercises master-node governance, and (Phase D) deploys new nodes onto supported cloud providers via the Datachain Foundation's hosted provisioning service.

Binary name: rope (not rope-cli)  ·  Source: crates/rope-cli/  ·  Default endpoint: https://erpc.datachain.network

Installation

# Build from source (recommended — there is no published cargo crate yet)
git clone https://github.com/KazeONGUENE/rope.git
cd rope
cargo build --release -p rope-cli

# Run
./target/release/rope --help

Operator basics

rope node --network mainnet --mode relay              # start a relay node
rope keygen --output ~/.rope/keys                     # generate Ed25519 keys
rope keygen --quantum                                 # post-quantum (Dilithium3)
rope info  --data-dir ~/.rope                         # show local node info
rope query status                                     # network health
rope query validators                                 # active validator set
rope token balance 0xabc…                             # check FAT balance
rope peer-id --key ~/.rope/keys/node.key --ip 1.2.3.4 # libp2p multiaddr

Deployer identity

Every Datachain Rope node carries a signed deployer attestation. The attestation binds the node's chain-of-trust public key to a real person or organization, and is exposed via the rope_nodeIdentity JSON-RPC method.

# Generate a founder-level Ed25519 key (run on a secure machine)
rope identity init-founder --output ~/.rope/founder.key

# Sign your node's [deployer] block
rope identity sign-deployer \
    --config /home/ubuntu/datachain-rope/deploy/config/rope-production.toml \
    --key ~/.rope/founder.key

# Show local or remote attestation
rope identity show --config rope-production.toml          # local
rope identity show --node-id 6dc3d5422e6a9b51…            # remote via RPC

# Verify the signature against the master-nodes.toml registry
rope identity verify --config rope-production.toml

Master-node governance

Datachain Rope mainnet has 4 master nodes (BLUE, GREEN, rpc-1, rpc-2) plus 2 knot witnesses (val-1, val-2). The Datachain founder identity (Kazé Alphonse Onguene; whitelisted domains datachain.one, epigraam.com, onguene.com, braincities.co) holds L0 authority. Mutating actions are signed Ed25519 payloads:

• rope_suspendNode — master node OR founder signature
• rope_isolateNode — founder signature only
• rope_eraseNode — founder signature only

rope governance list-masters                          # public, no auth
rope governance info                                  # registry + recent log

rope governance suspend \
    --node-id <hex> --reason "..." --ttl 3600 \
    --key ~/.rope/founder.key

rope governance isolate \
    --node-id <hex> --reason "..." \
    --key ~/.rope/founder.key

rope governance erase \
    --node-id <hex> --reason "..." \
    --key ~/.rope/founder.key

Cloud deployment (Phase D — MVP)

The CLI can provision new Datachain Rope nodes on supported cloud providers via the Datachain Foundation's hosted rope-deployer service. The Foundation maintains a sub-tenant on each provider so that third parties can spin up community nodes, federations, or witnesses without managing their own cloud account.

rope deploy exoscale     witness        --region ch-gva-2 --size medium
rope deploy exoscale     community-node --region ch-gva-2 --size large
rope deploy digitalocean rpc-slot       --region fra1     --size s-2vcpu-4gb
rope deploy local        community-node --dry-run

See deploy/EXOSCALE_AS_A_SERVICE.md for the full architecture (IAM, private networks, billing isolation, instance baking).

RPC API Reference

The Datachain Rope JSON-RPC API is available at https://erpc.datachain.network (WebSocket: wss://ws.datachain.network). It exposes two namespaces:

• rope_* — the canonical Quipu Primitive Canon methods (knots, strings, registry, labels)
• eth_* — EVM compatibility aliases so MetaMask, ethers.js, viem, and Foundry work unchanged

Method overview

Auth-gated methods: the five destructive methods (rope_createPersonalLedger, rope_appendToLedger, rope_untieKnot, rope_erasePersonalLedger, rope_anchorDeployerAttestation) return JSON-RPC error -32401 on the public listener. Write access is reserved for authorised operators and the on-box canonical agents. GDPR erasure requests from end users go through the compliance agent at https://compliance-agent.datachain.network/v1/gdpr/article17.

rope_knotIndex

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

// Response
{ "jsonrpc": "2.0", "result": "0x2d9f2a", "id": 1 }

rope_globalStats

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

// Response (abridged)
{
  "jsonrpc": "2.0",
  "result": {
    "total_strings": 7,
    "total_knots": 2075,
    "by_kind": { "wallet": { "strings": 7, "knots": 2075 } },
    "invariant_holds": true,
    "label_registry": { "assets": 419, "applications": 13, "agents": 5 }
  },
  "id": 1
}

rope_listStrings

// Request
{
  "jsonrpc": "2.0",
  "method": "rope_listStrings",
  "params": [{ "kind": "wallet", "offset": 0, "limit": 50 }],
  "id": 1
}

// Response (abridged)
{
  "jsonrpc": "2.0",
  "result": {
    "total": 7, "offset": 0, "limit": 50,
    "rpc_api_version": "1.4.0",
    "strings": [
      {
        "kind": "wallet",
        "string_id": "0x…",
        "genesis_knot_id": "0x…",
        "head_knot_id": "0x…",
        "knot_count": 413
      }
    ]
  },
  "id": 1
}

EVM compatibility aliases

All standard Ethereum JSON-RPC methods are served: eth_chainId (returns 0x425d4 = 271828), eth_blockNumber, eth_getBalance, eth_call, eth_sendRawTransaction, eth_getTransactionReceipt, eth_getLogs, eth_subscribe (WebSocket), and the rest of the standard surface. Existing EVM tooling needs no changes.

# Foundry cast against Datachain Rope
cast block-number --rpc-url https://erpc.datachain.network
cast balance 0x60FB32ef3A2381c2Ed71613F34fd56D56fCF4195 --rpc-url https://erpc.datachain.network

REST API Reference

DCScan (the Datachain Rope explorer) exposes a public REST API at https://dcscan.io/api/v1. CORS is open (Access-Control-Allow-Origin: *) — you can call it from any browser app or backend. Responses are JSON.

Network & chain data

Entity registry (Quipu Canon v1.2)

API keys

Bearer is a Datachain ID token from id.datachain.network — see Datachain ID. Pass your API key as the X-API-Key header on any /api/v1/* request to get identified usage tracking:

# Anonymous (fine for exploration)
curl -s https://dcscan.io/api/v1/stats

# Identified (attributed to your key, usage metrics on the API Keys page)
curl -s -H "X-API-Key: dcsk_…" https://dcscan.io/api/v1/stats

# Verify a key
curl -s -H "X-API-Key: dcsk_…" https://dcscan.io/api/v1/keys/verify

API Keys

Authenticated users can create and manage DCScan API keys directly from this page. Sign in with your Datawallet+ account (the same credentials as the mobile app) or with an EIP-191 wallet signature from a wallet linked to your Datawallet+ identity. Keys work on every https://dcscan.io/api/v1/* endpoint via the X-API-Key header.

Datachain ID — Ecosystem Authentication

https://id.datachain.network is the identity gateway for the entire Datachain Rope ecosystem. Any Datawallet+ owner can authenticate on any ecosystem platform (DCScan, Tanastok, DCSwap, NaturaProof, Careaway…) with their credentials or their wallet public key. The gateway issues Ed25519-signed JWTs that every service can verify offline against the published JWKS.

Endpoints

Wallet-signature login (EIP-191)

Sign this exact message with personal_sign, where {address} is lowercase and {timestamp} is unix seconds (±5 minutes):

DATACHAIN-ID-AUTH
{address}
{timestamp}

const address = (await ethereum.request({ method: 'eth_requestAccounts' }))[0].toLowerCase();
const timestamp = Math.floor(Date.now() / 1000);
const message = `DATACHAIN-ID-AUTH\n${address}\n${timestamp}`;
const signature = await ethereum.request({ method: 'personal_sign', params: [message, address] });

const res = await fetch('https://id.datachain.network/v1/auth/wallet', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ address, timestamp, signature })
});
const { token, user } = await res.json();
// token → use as  Authorization: Bearer <token>  on any ecosystem API

Token claims

{
  "iss": "https://id.datachain.network",
  "sub": "datawallet-user-uuid",
  "aud": "datachain-ecosystem",
  "email": "user@example.com",
  "did": "did:datachain:…",
  "primary_address": "0x…",
  "wallets": ["0x…"],
  "chain_id": 271828,
  "exp": 1780000000
}

Services verify tokens either offline (fetch the JWKS once, verify the Ed25519 signature locally) or by POSTing to /v1/auth/introspect.

WebSocket API

Real-time subscriptions are served at wss://ws.datachain.network using the standard eth_subscribe interface.

Subscribe to new anchor knots

// Native WebSocket
const ws = new WebSocket('wss://ws.datachain.network');
ws.onopen = () => ws.send(JSON.stringify({
  jsonrpc: '2.0', method: 'eth_subscribe', params: ['newHeads'], id: 1
}));
ws.onmessage = (e) => console.log(JSON.parse(e.data));

// ethers.js v6
import { WebSocketProvider } from 'ethers';
const provider = new WebSocketProvider('wss://ws.datachain.network');
provider.on('block', (knotIndex) => console.log('new anchor knot', knotIndex));

Subscribe to contract events

ws.send(JSON.stringify({
  jsonrpc: '2.0', method: 'eth_subscribe',
  params: ['logs', {
    address: '0x285eecf51d5f0a6ab8d8151139b4d19b05c6b3e4',   // WFAT
    topics: []                                                // all events
  }],
  id: 2
}));

Supported subscriptions

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=your-walletconnect-project-id
EXPO_PUBLIC_INFURA_API_KEY=your-infura-project-id

# 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'
  ]
}

SDK

Datachain Rope is EVM-wire-compatible, so every mainstream Web3 SDK works out of the box against https://erpc.datachain.network with chain ID 271828.

ethers.js v6

import { JsonRpcProvider, Wallet, parseEther } from 'ethers';

const provider = new JsonRpcProvider('https://erpc.datachain.network', {
  chainId: 271828, name: 'datachain-rope'
});

const wallet = new Wallet(process.env.PRIVATE_KEY, provider);
const tx = await wallet.sendTransaction({ to: '0x…', value: parseEther('1') }); // 1 FAT
await tx.wait();  // finality ≈ 3s

viem

import { createPublicClient, defineChain, http } from 'viem';

export const datachainRope = defineChain({
  id: 271828,
  name: 'Datachain Rope',
  nativeCurrency: { name: 'DC FAT', symbol: 'FAT', decimals: 18 },
  rpcUrls: { default: {
    http: ['https://erpc.datachain.network'],
    webSocket: ['wss://ws.datachain.network']
  }},
  blockExplorers: { default: { name: 'DCScan', url: 'https://dcscan.io' } }
});

const client = createPublicClient({ chain: datachainRope, transport: http() });
console.log(await client.getBlockNumber());

web3.py

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://erpc.datachain.network'))
assert w3.eth.chain_id == 271828
print(w3.eth.block_number)

Foundry

# foundry.toml
[rpc_endpoints]
rope = "https://erpc.datachain.network"

# Deploy
forge create src/MyToken.sol:MyToken --rpc-url rope --private-key $PK

# Read
cast call 0x285eecf51d5f0a6ab8d8151139b4d19b05c6b3e4 'symbol()(string)' --rpc-url rope

DatawalletConnect (dApp ↔ Datawallet+)

For user-facing dApps, @datawallet/connect adds "Connect with Datawallet+" in one line — see the full DatawalletConnect SDK reference above. For backend service authentication, use Datachain ID tokens.

Smart Contracts

Datachain Rope runs a full EVM execution layer. Solidity contracts deploy unchanged. The native fungible-token standard is DCR-20 (wire-compatible with ERC-20 tooling); ERC-721, ERC-3643 (T-REX), and ERC-734/735 (ONCHAINID) keep their original names.

Token standards

Core deployed contracts (mainnet, chain 271828)

Browse any contract on DCScan — Tanastok tokenized-asset contracts (DCNFT + ERC-3643 pairs) are labelled automatically on their address pages.

Deploying

# Hardhat — hardhat.config.js
module.exports = {
  networks: {
    rope: {
      url: 'https://erpc.datachain.network',
      chainId: 271828,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

# Foundry
forge create src/MyContract.sol:MyContract \
  --rpc-url https://erpc.datachain.network \
  --private-key $PRIVATE_KEY

Upgradeable-proxy mandate: production contracts on Datachain Rope must use upgradeable proxy patterns (UUPS / Transparent / CREATE2 as appropriate) so addresses remain permanent across execution-layer upgrades. Gas is paid in DC FAT at 1 gwei base.