Skip to main content

TAPLE Core Documentation

Build scalable, energy-efficient DLT applications for asset traceability and provenance tracking with TAPLE’s reference library.

Get StartedAPI Reference

Quick start

Get up and running with TAPLE Core in minutes.

1

Add TAPLE Core to your project

Add the dependency to your Cargo.toml:
Cargo.toml
[dependencies]
taple-core = "0.3"
TAPLE Core requires Rust 1.67 or later.
2

Configure and build a node

Create a node with your settings and database implementation:
use taple_core::{crypto::*, *};

let node_key_pair = crypto::KeyPair::Ed25519(
    Ed25519KeyPair::from_seed(&[])
);

let mut settings = Settings::default();
settings.node.secret_key = hex::encode(
    node_key_pair.secret_key_bytes()
);

let (mut node, api) = Node::build(
    settings, 
    MemoryManager::new()
)?;
3

Create your first governance

Create a governance subject to manage your network:
let governance_key = api
    .add_keys(KeyDerivator::Ed25519)
    .await?;

let request = EventRequest::Create(StartRequest {
    governance_id: DigestIdentifier::default(),
    schema_id: "governance".to_string(),
    namespace: "".to_string(),
    name: "".to_string(),
    public_key: governance_key,
});

let signed_request = Signed {
    content: request.clone(),
    signature: Signature::new(&request, &node_key_pair)?,
};

let request_id = api.external_request(signed_request).await?;
4

Listen for notifications

Monitor network events and subject updates:
if let Notification::NewEvent { sn, subject_id } = 
    node.recv_notification().await? 
{
    println!("New event on subject: {}", subject_id);
}

Explore by topic

Learn about TAPLE Core’s architecture and capabilities.

Core Concepts

Understand TAPLE’s architecture, governance model, and event-driven design.

Cryptography

Learn about supported cryptographic schemes and key management.

Subjects & Events

Explore the lifecycle of subjects and their events in the network.

Database Integration

Implement custom database backends with the pluggable storage layer.

Smart Contracts

Execute WASM-based smart contracts for state validation and transformation.

Network Configuration

Configure peer-to-peer networking, bootstrap nodes, and external addresses.

Key features

TAPLE Core is designed for scalable, energy-efficient traceability applications.

Lightweight & Scalable

Designed to run on resource-constrained devices while scaling to meet traceability demands.

Flexible Cryptography

Support for Ed25519 and Secp256k1 signature schemes with pluggable key derivation.

Governance Model

Built-in governance with approval and validation workflows for permissioned networks.

Pluggable Storage

Abstract database layer supporting in-memory and persistent storage implementations.

Ready to build with TAPLE?

Start building traceable, sustainable applications with TAPLE Core’s powerful DLT capabilities.

Get StartedView on GitHub