+
+
+
+
Back to Ecosystem

Continuum

Where data meets integrity.

The decentralized protocol that verifies and immortalizes every data exchange. Open-source, auditable, and permanent—the trust infrastructure that makes Myn and Ethos possible.

View on GitHub

Network Explorer

Immutable records
<1s
Transaction finality
MIT
Open source license
Ed25519
Cryptographic signing
Architecture

Built on
Polkadot substrate

Leveraging the most advanced blockchain infrastructure for data integrity

Cryptographic Verification

Every consent action is signed with Ed25519 keys and recorded on-chain. Mathematical proof that consent was granted, not just claimed.

  • Ed25519 signature scheme
  • Merkle tree verification
  • Zero-knowledge proofs

Immutable Records

All transactions recorded permanently on Polkadot parachain. Once written, consent history cannot be altered or deleted.

  • Append-only ledger
  • Byzantine fault tolerant
  • Global state consensus

Open Infrastructure

Build on top. Integrate. Extend. MIT licensed with full documentation and reference implementations.

  • MIT open source
  • Public audit trail
  • Community governed
Smart Contracts

ink! smart contracts
on Polkadot

Written in Rust using ink! v5.0. Compiled to WebAssembly for maximum performance and security. Every function is tested, audited, and verifiable on-chain.

DataAccessControl

Manages access requests, approvals, and revocations with time-based expiration

PaymentEscrow

Handles DOT token escrow, automatic release, and refunds on revocation

ConsentRegistry

Immutable registry of all consent grants with cryptographic signatures

Deploy Guide
data_access.rs
#[ink::contract]
mod data_access {
    use ink::storage::Mapping;

    #[ink(storage)]
    pub struct DataAccess {
        requests: Mapping<u64, Request>,
        next_id: u64,
    }

    impl DataAccess {
        #[ink(message)]
        pub fn request_access(
            &mut self,
            customer: AccountId,
            fields: Vec<String>,
            duration: u64,
            payment: Balance
        ) -> u64 {
            // Record request on-chain
            let id = self.next_id;
            self.requests.insert(id, &Request {
                customer,
                organization: self.env()
                    .caller(),
                fields,
                duration,
                payment,
                status: Pending,
            });
            self.next_id += 1;
            id
        }

        #[ink(message)]
        pub fn approve(&mut self, id: u64) {
            // Cryptographic verification
            // Escrow payment
            // Grant access
        }
    }
}
Data Flow
1

Request Initiated

Organization calls request_access() with customer address, required fields, duration, and payment. Transaction signed and submitted to mempool.

2

On-Chain Recording

Validators include transaction in next block. State updated with new AccessRequest struct. Event emitted, picked up by Myn app indexer.

3

Customer Approval

Customer reviews in Myn and calls approve(). Their private key signs the transaction, creating cryptographic proof of consent. Payment escrowed automatically.

4

Data Exchange

Ethos queries contract for active approvals. Encrypted data transferred off-chain via secure channel. Access automatically expires after duration. All logged on-chain.

For Developers

Build on Continuum

Everything you need to integrate with the trust layer

Documentation

Complete API reference, integration guides, and tutorials. Learn how to query consent records, submit requests, and build custom applications.

Read the docs →

GitHub Repository

Browse source code, file issues, and contribute. All contracts, pallets, and SDK implementations are open source under MIT license.

View on GitHub →

SDKs & Libraries

JavaScript, Rust, and Python SDKs for interacting with smart contracts. Type-safe bindings generated from contract metadata.

Install packages →

CLI Tools

Command-line utilities for deploying contracts, querying state, and managing on-chain data. Works with any Substrate-based chain.

Download CLI →
Technical Specifications

Built for
performance

Optimized for high-throughput consent verification with sub-second finality. Horizontally scalable across Polkadot parachain network.

< 1s Finality

Transactions confirmed in under one second using GRANDPA finality

1000+ TPS

Over 1000 transactions per second on parachain

WebAssembly

Contracts compiled to WASM for deterministic execution

Cross-Chain

XCMP messaging for interoperability across Polkadot ecosystem

ink! 5.0
Smart Contract Framework
Rust
Primary Language
FRAME
Substrate Pallets
Polkadot
Relay Chain

Build. Integrate.
Verify.

Start building on the trust layer for decentralized data exchange.

View on GitHub