TAKO Smart Contracts

┌─────────────────────────────────────────────────────────────┐
│                      Your Rust Contract                     │
│                     (uses tako_sdk)                         │
└───────────────────────────┬─────────────────────────────────┘
                            │ compile (cargo-tako)
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    TBPFv3 Bytecode (.so)                    │
└───────────────────────────┬─────────────────────────────────┘
                            │ deploy
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                      TAKO Runtime                           │
│  ┌──────────────┬───────────────┬────────────────────────┐ │
│  │   Executor   │   Storage     │      Syscalls          │ │
│  │   (TBPFv3)   │   (RocksDB)   │  (Native Features)     │ │
│  └──────────────┴───────────────┴────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    TOS Blockchain                           │
│           (BlockDAG, Consensus, State)                      │
└─────────────────────────────────────────────────────────────┘

# Install TOS Platform Tools
curl -sSf https://tos.network/install.sh | sh
 
# Verify installation
cargo-tako --version

# 1. Download (example for macOS Apple Silicon)
curl -LO https://github.com/tos-network/platform-tools/releases/latest/download/tos-platform-tools-osx-aarch64.tar.bz2
 
# 2. Create installation directory
mkdir -p ~/.cache/tos/v1.54
 
# 3. Extract
tar -xjf tos-platform-tools-osx-aarch64.tar.bz2 -C ~/.cache/tos/v1.54
 
# 4. Add to PATH (add to ~/.bashrc or ~/.zshrc)
export PATH="$HOME/.cache/tos/v1.54/tos-platform-tools/llvm/bin:$PATH"
export PATH="$HOME/.cache/tos/v1.54/tos-platform-tools/rust/bin:$PATH"
 
# 5. Verify installation
cargo-tako --version
# Output: cargo-tako 0.3.1

~/.cache/tos/v1.54/tos-platform-tools/
├── llvm/
│   └── bin/
│       ├── clang           # LLVM Clang 20.1.7
│       ├── lld             # LLVM Linker
│       └── ...
├── rust/
│   └── bin/
│       ├── cargo           # Cargo 0.94.0
│       ├── cargo-tako      # TAKO build tool 0.3.1
│       ├── rustc           # Rust 1.91.0-dev
│       └── rustfmt
└── version.md

# Create new contract project
cargo-tako new my_contract
cd my_contract

//! src/lib.rs
#![no_std]
#![no_main]
 
use tako_sdk::*;
 
#[no_mangle]
pub extern "C" fn entrypoint() -> u64 {
    log("Hello, TOS!");
    SUCCESS
}
 
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

# Build the contract
cargo-tako build
 
# Deploy to testnet
tos_wallet deploy_contract ./target/deploy/my_contract.so

#![no_std]        // No standard library (blockchain environment)
#![no_main]       // No main function (uses entrypoint)
 
use tako_sdk::*;  // Import TAKO SDK
 
// Entry point - called when contract is invoked
#[no_mangle]
pub extern "C" fn entrypoint() -> u64 {
    // Your contract logic here
    SUCCESS
}
 
// Panic handler - required for no_std
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

// Success - transaction succeeds
return SUCCESS;  // 0
 
// Error - transaction fails
return ERROR;    // 1
 
// Custom error codes
return 1001;     // Application-specific errors

// Write to storage
storage_write(b"my_key", &value_bytes)?;
 
// Read from storage
let mut buffer = [0u8; 32];
let len = storage_read(b"my_key", &mut buffer);

// Call another contract
let result = cpi_call(
    &target_contract,  // Contract address
    &input_data,       // Call data
    &mut return_data,  // Return buffer
)?;

// VRF Randomness
let random = vrf_random(&seed)?;
 
// Referral queries
let uplines = tos_get_uplines(&user, 3)?;
 
// Transfers
transfer(&recipient, amount)?;

[build]
target = "tbpfv3-tos-tos"
 
[target.tbpfv3-tos-tos]
rustflags = [
    "-C", "link-arg=-z", "-C", "link-arg=notext",
]

[toolchain]
channel = "1.91.0-dev"

// Good - handles overflow
let result = amount.checked_add(fee).ok_or(ERR_OVERFLOW)?;
 
// Bad - can panic
let result = amount + fee;

// Validate at entry
if amount == 0 {
    return ERR_INVALID_AMOUNT;
}
 
if is_zero_address(&recipient) {
    return ERR_INVALID_ADDRESS;
}

// Log important operations
log("Transfer executed");
log_u64(amount, from_balance, to_balance, 0, 0);

match storage_write(key, &value) {
    Ok(_) => SUCCESS,
    Err(e) => {
        log("Storage write failed");
        e
    }
}