whitepaper Kanari SDK

Abstract

Kanari Network is a fast, secure payment infrastructure built for real-time transactions. It uses advanced technology to process payments in less than 1 second with no fees for end users.

Key Features:

• Speed: Payments finalize in ~300 milliseconds
• No Fees: End users never pay transaction fees
• Security: Built with quantum-resistant cryptography
• Scale: Handles 50,000+ transactions per second
• Safety: Uses MoveVM to prevent asset loss or duplication

1. Introduction

The Problem Traditional payment systems and blockchains have significant limitations:

• Banking systems: Slow settlement (1-3 days), high fees, limited accessibility
• Credit cards: High merchant fees (2-4%), chargeback risks, fraud concerns
• Traditional blockchains: High gas fees, slow finality, poor user experience

Kanari's Solution Kanari provides a universal payment infrastructure optimized for real-time transactions:

• Instant Payments: Complete settlement in under 1 second
• Zero User Fees: Businesses cover infrastructure costs
• Simple Integration: Works with existing user accounts and systems
• High Performance: 50,000+ TPS supports massive scale applications

Primary Use Cases:

• Gaming: In-game purchases, microtransactions, player-to-player trading
• E-commerce: Instant checkout, cross-border payments, subscription billing
• Financial Services: Remittances, peer-to-peer transfers, digital wallets
• Digital Content: NFT marketplaces, content monetization, creator payments

How It Works Kanari combines proven technologies in a new way:

• Move Virtual Machine: Safe smart contracts for financial assets
• DAG Consensus: Parallel processing instead of sequential blocks
• Rust Programming: Fast, memory-safe code
• Post-Quantum Crypto: Ready for future security threats

This whitepaper explains how Kanari works as a universal payment infrastructure, with clear formulas and practical examples for all use cases.

2 Architecture & Centauri Consensus

2.1 What is DAG Consensus?

Traditional blockchains process transactions one block at a time, creating bottlenecks for payment systems. Kanari uses a Directed Acyclic Graph (DAG) structure that allows multiple validators to process transactions simultaneously.

Key Difference:

• Blockchain: Linear sequence → Slow, sequential processing
• DAG: Parallel structure → Fast, concurrent processing

This makes DAG ideal for high-frequency payment networks requiring instant settlement.

2.2 How Centauri Consensus Works

Centauri uses the Bullshark protocol with a simple 3-round commit process:

Round 1: Leader creates a vertex (transaction batch) Round 2: Other validators reference the leader's vertex
Round 3: If enough validators agree, the vertex is committed

Mathematical Formulas

Byzantine Fault Tolerance (BFT) For a network with n validators:

• Maximum faulty validators tolerated: f = floor((n-1)/3)
• Minimum honest validators needed: 2f + 1

Example Calculation:

• With 4 validators: f = floor((4-1)/3) = 1
• Need 2(1) + 1 = 3 honest validators to reach consensus

Throughput Formula Maximum Transactions Per Second (TPS):

TPS = (Validators × Transactions per Vertex) / Finality Time

Example:

• 4 validators × 500 transactions per vertex ÷ 0.3 seconds = ~6,667 TPS
• With optimizations: Up to 50,000+ TPS

This throughput supports global payment volumes including e-commerce, remittances, and financial services.

2.3 Performance Characteristics

These metrics make Kanari suitable for real-time payment processing across all industries.

2.4 Security Model

Network Security Formula: The probability of network compromise decreases exponentially with more validators:

Security = 1 - (f/n)^k

Where:

• f = maximum faulty validators
• n = total validators
• k = number of consensus rounds

Light Client Verification Light clients verify transactions using Merkle proofs:

verify_proof(state_root, account_data, merkle_path) = true/false

This allows mobile wallets, e-commerce platforms, and banking apps to verify payments without running full nodes.

2.5 Simple Architecture Overview

Kanari's system is built from specialized components:

Core Components:

• centauri: Handles consensus and transaction ordering
• kanari-core: Coordinates the entire system
• kanari-move-runtime: Executes smart contracts safely
• kanari-crypto: Provides secure cryptography
• kanari-node: Runs the complete network node

Each component has a specific job, making the system reliable and maintainable for universal payment applications.

3. MoveVM Execution Layer

3.1 Why MoveVM for Universal Payments?

MoveVM is perfect for payment systems because it treats digital assets as resources that cannot be accidentally lost, copied, or duplicated.

Traditional Smart Contracts:

• Assets are just numbers in a database
• Easy to create bugs that lose or duplicate money

MoveVM Resources:

• Assets are physical objects in code
• Cannot be copied or discarded without explicit actions
• Compiler prevents common financial mistakes

This makes MoveVM ideal for stablecoins, loyalty points, gift cards, and any financial instrument where asset integrity is critical.

3.2 Gasless Transaction Model

End users never pay gas fees. Instead, the system uses a simple resource accounting model:

Resource Accounting Formula:

Total Steps = Σ(Operation Cost × Quantity)

Each transaction has a step limit (e.g., 10,000 steps). If a transaction exceeds this limit, it's rejected—but users aren't charged.

Operation Costs:

• Simple transfer: 100 steps
• Multi-currency swap: 500 steps
• Complex payment logic: 1,000 steps
• Publish new payment module: 5,000 steps

This prevents spam attacks while keeping transactions free for users across all payment scenarios.

3.3 Universal Payment Primitives

Kanari provides ready-to-use building blocks for all payment applications:

Core Modules:

• Coins: Fungible tokens for stablecoins, loyalty points, currencies
• NFTs: Unique assets like gift cards, certificates, tickets
• Accounts: Secure wallets with multi-signature support
• Clock: Time-based payments for subscriptions and escrow

Example: Cross-Border Payment

// Send USDC to international recipient
public entry fun send_international(
    sender_coin: &mut Coin<USDC>, 
    amount: u64,
    recipient: address,
    ctx: &mut TxContext
) {
    // Verify sufficient balance
    assert!(coin::value(sender_coin) >= amount, 1);
    
    // Split amount to send
    let payment = coin::split(sender_coin, amount, ctx);
    
    // Instant international transfer
    transfer::public_transfer(payment, recipient);
}

3.4 Performance for Real-Time Payments

Execution Speed Formula:

Total Time = Execution Time + Finality Time

• Execution Time: ~10ms (transaction processing)
• Finality Time: ~300ms (network confirmation)
• Total: ~310ms for complete payment settlement

This speed enables real-time payments for e-commerce, remittances, and instant settlements.

3.5 Simple Development Workflow

Developers can build payment applications easily:

# Create new stablecoin
kanari move new my_stablecoin

# Test payment flows  
kanari move test ./my_stablecoin

# Deploy to network
kanari move publish ./my_stablecoin

The system handles all complexity—developers focus on payment logic for any industry.

4. The Zero-Fee Payment Infrastructure

4.1 Universal Zero-Fee Model

Kanari eliminates transaction fees for end users across all payment scenarios:

Traditional Payment Costs:

• Credit Cards: 2-4% + $0.30 per transaction
• Bank Transfers: $15-50 for international, 1-3 day settlement
• Blockchain: $0.50-$20+ in gas fees, variable finality

Kanari Model:

• End Users: Pay $0 in transaction fees
• Merchants/Businesses: Cover minimal infrastructure costs
• Predictable Economics: Fixed costs enable better business planning

4.2 PoA Economic Sustainability

Since Kanari uses Proof of Authority (PoA) consensus, there are no validator rewards or token inflation. The network stays sustainable through operational efficiency:

Infrastructure Cost Formula:

Cost per Transaction = (Total Infrastructure Cost) / Transactions

Example Calculation:

• Monthly server costs: $1,000
• Monthly transactions: 10,000,000
• Cost per transaction: $1,000 / 10,000,000 = $0.0001

Businesses absorb this minimal cost as part of their normal operational expenses, similar to payment processor or database costs.

4.3 Universal Account System

Users can link any existing account to Kanari seamlessly:

Account Mapping Formula:

Payment Address = hash(User_ID + Salt)

Integration Examples:

• E-commerce: Map email addresses to payment addresses
• Gaming: Map game UIDs to payment addresses
• Banking: Map phone numbers to payment addresses
• Social: Map usernames to payment addresses

No wallet setup or cryptocurrency knowledge required—users interact with familiar identifiers.

4.4 Micro and Macro Payment Economics

Cost Comparison Across Scenarios:

Business Revenue Formula:

Net Revenue = Gross Revenue - Infrastructure Cost

Since infrastructure costs are fixed and extremely low (~$0.0001 per transaction), businesses keep virtually all revenue while offering free payments to customers.

4.5 Real-World Payment Scenarios

E-commerce Platform:

• 50,000 daily transactions
• Average transaction value: $75
• Traditional processing fees: ~$150,000/month
• Kanari cost: ~$15/month

Remittance Service:

• Cross-border money transfers
• Instant settlement instead of 1-3 days
• Near-zero fees instead of 5-10% charges
• Transparent exchange rates

Digital Content Marketplace:

• Creator monetization with instant payouts
• Fractional payments (pay-per-article, pay-per-minute)
• Global accessibility without banking barriers

Gaming Platform:

• In-game purchases with instant confirmation
• Player-to-player trading with zero fees
• Tournament prize distributions in seconds

This universal payment infrastructure enables new business models across all industries by removing the friction and cost barriers of traditional payment systems.

5. Infrastructure & Networking

5.1 Rust Performance Benefits

Kanari is built in Rust for three key reasons:

Memory Safety Formula:

Bugs Prevented = Memory Errors + Data Races + Null Pointers

Rust's compiler prevents these at compile time, making the system more reliable for financial infrastructure.

Performance Characteristics:

• Near C/C++ speed with automatic memory management
• Zero-cost abstractions mean no performance penalty for safety
• Efficient multi-core utilization

This ensures banking-grade reliability for payment processing.

5.2 Simple Networking Model

Kanari uses libp2p for peer-to-peer networking:

Network Topology:

• Each node connects to 10-20 other nodes
• Automatic discovery finds new peers
• Messages propagate in ~100ms across global network

Bandwidth Formula:

Total Bandwidth = (Transactions × Size) / Time

Example:

• 50,000 TPS × 200 bytes per transaction ÷ 1 second = 10 MB/s per node

This is manageable even on modest internet connections, enabling global payment accessibility.

5.3 Storage Efficiency

Kanari uses RocksDB for persistent storage with smart compression:

Storage Formula:

Compressed Size = Original Size × Compression Ratio

Typical Values:

• Original transaction size: 200 bytes
• After Zstd compression: ~80 bytes
• Compression ratio: ~40%

This reduces storage costs significantly for high-volume payment processors.

5.4 Cryptography Made Simple

Kanari supports both current and future-proof cryptography:

Security Levels:

• Current: Ed25519 signatures (fast, secure today)
• Future: Dilithium post-quantum signatures (quantum-resistant)
• Hybrid: Both together for smooth transition

Key Generation Formula:

Public Key = generate_public(private_key)
Signature = sign(message, private_key)
verify(message, signature, public_key) = true/false

The system handles all complexity—developers just use simple functions for secure payment processing.

5.5 Easy Deployment for Payment Services

Single Node Setup:

# Start a payment node (Windows)
.\start-node.ps1

# Multi-node setup for high availability  
.\setup-multi-node.ps1

Resource Requirements:

• CPU: 4+ cores recommended
• RAM: 8+ GB
• Storage: 100+ GB SSD
• Network: 10+ Mbps upload

This makes it accessible for payment processors, e-commerce platforms, and financial institutions of all sizes.

6. The Universal Payment Ecosystem

6.1 Developer Tools for All Industries

Kanari provides simple tools for building payment applications across all sectors:

Tool Compatibility Matrix:

6.2 Simple Integration Examples

Mobile Wallet (Flutter/Dart):

// Create payment wallet with Ed25519 curve
final wallet = await KanariWallet.generate(curve: KanariCurve.ed25519);

// Initialize client
final client = KanariClient('http://localhost:19001');

// Send instant payment
final result = await client.transfer(
  wallet: wallet,
  recipient: '0x9z8y7x6w5v4u3t2s1r0q9p8o7n6m5l4k3j2i1h0g9f8e7d6c5b4a3z2y1x0w9v8u',
  amount: 50000000, // 50 KANARI tokens
);

print('Instant payment sent! Transaction: ${result.hash}');

Enterprise Integration (REST API):

# Get account balance
curl -X POST http://localhost:19001 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "kanari_getBalance",
    "params": "0x1234567890123456789012345678901234567890123456789012345678901234",
    "id": 1
  }'

# Submit transaction (requires proper signature structure)
# Note: Direct REST submission requires BCS-serialized transaction with Blake3 hash signature

6.3 Payment Explorer

KanariScan provides real-time payment network visibility:

Explorer Features:

• Account balances and transaction history
• Cross-border payment tracking
• Currency exchange rate monitoring
• Business analytics and reporting
• Smart contract verification

6.4 Universal Development Workflow

Simple 3-Step Process:

1. Build: Create payment logic with Move smart contracts
2. Test: Run locally with testnet
3. Deploy: Launch to mainnet

CLI Commands:

# Create payment token
kanari move new usd_stablecoin

# Run build
kanari move build


# Test payment flows  
kanari move test 

# Deploy to production
kanari move publish 

7. Roadmap & Conclusion

7.1 Universal Payment Network Growth

Kanari's value grows with adoption across all payment sectors following Metcalfe's Law:

Network Value Formula:

Network Value = k × n²

Where:

• k = constant representing utility per connection
• n = number of active users across all industries

Example Growth:

• 10,000 users → Value = k × 100,000,000
• 100,000 users → Value = k × 10,000,000,000
• 10x user growth = 100x value increase

7.2 Universal Adoption Roadmap

Phase 1: Foundation (Complete)

• ✅ DAG consensus working at 50,000+ TPS
• ✅ MoveVM integration complete
• ✅ Zero fee model implemented
• ✅ Security audits passed
• ✅ Multi-currency support (USDC, EURO, THB examples)

Phase 2: Ecosystem Expansion (In Progress)

• 🚧 Mobile SDKs for iOS/Android wallets
• 🚧 E-commerce plugins (Shopify, WooCommerce)
• 🚧 Banking API integrations
• 🚧 Developer documentation and tutorials
• 🚧 Public testnet launch

Phase 3: Global Payment Network (Coming Soon)

• 🔜 Cross-border payment partnerships
• 🔜 Regulatory compliance frameworks (KYC/AML)
• 🔜 Enterprise banking integrations
• 🔜 Central bank digital currency (CBDC) compatibility
• 🔜 Global merchant acceptance network

7.3 Performance Scaling for Global Payments

As the network grows, performance improves through parallelization:

Scaling Formula:

Max TPS = Base TPS × Validators

Current: 50,000 TPS with 4 validators Future: 500,000+ TPS with 40 validators

The system scales linearly to support global payment volumes.

7.4 Quantum Safety for Financial Infrastructure

Cryptography Transition Plan:

• 2026: Hybrid signatures (Ed25519 + Dilithium)
• 2028: Full post-quantum migration
• 2030: Quantum-resistant by default

This ensures long-term security for financial transactions without disrupting current users.

7.5 Conclusion

Kanari Network solves the fundamental problems preventing blockchain adoption in universal payments:

Problem → Solution:

• Slow settlement → 300ms finality
• High fees → Zero user fees
• Complex onboarding → Simple account mapping
• Poor scalability → 50,000+ TPS
• Security concerns → Quantum-resistant crypto

By focusing on payment infrastructure rather than just gaming, Kanari enables instant, fee-free transactions for e-commerce, remittances, digital content, financial services, and gaming—all on a single, secure network.

Getting Started:

• Developers: Visit https://docs.kanarinetwork.site
• Financial Institutions: Run kanari node --help to start

The future of payments is fast, free, and universal—and it starts with Kanari.