Settlement Engine

On-chain settlement with escrow, micropayment channels, and batch processing

The settlement engine handles all financial finality on the Tenzro Ledger. Immediate settlements for one-off transactions, escrow with proof-based release for complex agreements, and micropayment channels for high-frequency per-token billing.

Key Features

Immediate Settlement

Direct on-chain transfer with receipt generation. Verify sender balance, deduct, credit, collect fees

Escrow Settlements

Lock funds with release conditions: provider signature, ZK proof submission, or time elapsed

Micropayment Channels

Off-chain state channels for per-token billing. Open with escrowed TNZO, stream updates, settle on close

Batch Processing

Atomic multi-settlement operations. All-or-nothing: if any settlement fails, all roll back

Fee Collection

Network fee: 0.5% on all settlements. Fees routed to treasury for distribution to validators and stakers

Proof Verification

ZK and TEE proof verification during settlement. Verify computation was correct before releasing funds

Settlement Architecture

Code Examples

Micropayment Channel

use tenzro_settlement::MicropaymentChannelManager;

let manager = MicropaymentChannelManager::new(storage);

// Open channel
let channel = manager.open_channel(
    sender,
    receiver,
    Amount::tnzo(10.0),
    Duration::from_secs(3600),
)?;

// Update state (off-chain)
manager.update_state(&channel.id, new_balance, nonce, signature)?;

// Close and settle on-chain
let receipt = manager.close_channel(&channel.id)?;

Escrow Settlement

use tenzro_settlement::{SettlementEngine, EscrowCondition};

let engine = SettlementEngine::new(config);

// Create escrow
let escrow = engine.create_escrow(
    payer,
    payee,
    Amount::tnzo(100.0),
    vec![
        EscrowCondition::ProofSubmission,
        EscrowCondition::TimeElapse(Duration::from_secs(86400)),
    ],
)?;

// Release with proof
engine.release_escrow(&escrow.id, &zk_proof)?;

Batch Settlement

use tenzro_settlement::{SettlementEngine, SettlementRequest};

let engine = SettlementEngine::new(config);

// Create multiple settlement requests
let requests = vec![
    SettlementRequest::immediate(payer1, payee1, Amount::tnzo(50.0)),
    SettlementRequest::immediate(payer2, payee2, Amount::tnzo(75.0)),
    SettlementRequest::immediate(payer3, payee3, Amount::tnzo(100.0)),
];

// Process atomically - all succeed or all fail
let receipts = engine.process_batch(requests)?;

// All settlements completed successfully
for receipt in receipts {
    println!("Settlement {} completed", receipt.id);
}

Fee Calculation

use tenzro_settlement::{SettlementEngine, Amount};

let engine = SettlementEngine::new(config);

// Network fee: 0.5% of settlement amount
let amount = Amount::tnzo(1000.0);
let fee = engine.calculate_fee(&amount);

println!("Settlement amount: {} TNZO", amount);
println!("Network fee: {} TNZO", fee);
println!("Recipient receives: {} TNZO", amount - fee);

// Output:
// Settlement amount: 1000.000000000000000000 TNZO
// Network fee: 5.000000000000000000 TNZO
// Recipient receives: 995.000000000000000000 TNZO

Settlement Modes

Immediate Settlement

Direct transfer with instant finality. Ideal for one-time payments, invoice settlements, and simple transfers.

Balance verification before execution
Atomic debit and credit operations
Network fee deduction (0.5%)
Receipt generation with transaction hash

Escrow Settlement

Conditional release based on proof submission, signatures, or time. Perfect for AI inference payments, staking rewards, and multi-party agreements.

Funds locked in smart contract escrow
Multiple release conditions supported
ZK proof verification before release
TEE attestation verification
Time-based automatic release

Micropayment Channels

Off-chain state channels for high-frequency, low-value payments. Essential for per-token AI billing and streaming payments.

Open channel with initial TNZO deposit
Off-chain state updates with signatures
Unlimited updates during channel lifetime
On-chain settlement only on close
Dispute resolution for conflicting states

Build with Settlement Engine

Integrate on-chain settlement into your AI applications with escrow protection and micropayment channels.

Read Documentation Explore Products