TAKO SDK Reference

[dependencies]
tako-sdk = { git = "https://github.com/tos-network/tako", branch = "main" }

use tako_sdk::*;

/// Success return code
pub const SUCCESS: u64 = 0;
 
/// Generic error return code
pub const ERROR: u64 = 1;

pub fn get_tx_sender() -> [u8; 32];

let sender = get_tx_sender();

pub fn get_caller() -> [u8; 32];

pub fn get_contract_hash() -> [u8; 32];

pub fn get_call_value() -> u64;

let amount = get_call_value();
if amount == 0 {
    return ERR_NO_VALUE;
}

pub fn get_block_number() -> u64;

pub fn get_block_hash() -> [u8; 32];

pub fn get_timestamp() -> u64;

pub fn get_input_data(buffer: &mut [u8]) -> u32;

let mut input = [0u8; 1024];
let len = get_input_data(&mut input);
 
// Parse opcode and parameters
let opcode = input[0];
let params = &input[1..len as usize];

pub fn set_return_data(data: &[u8]) -> Result<(), u64>;

let balance = get_balance(&account);
let result = balance.to_le_bytes();
set_return_data(&result)?;

pub fn storage_read(key: &[u8], buffer: &mut [u8]) -> u32;

const COUNTER_KEY: &[u8] = b"counter";
 
let mut buffer = [0u8; 8];
let len = storage_read(COUNTER_KEY, &mut buffer);
 
let value = if len == 8 {
    u64::from_le_bytes(buffer)
} else {
    0 // Default value
};

pub fn storage_write(key: &[u8], value: &[u8]) -> Result<(), u64>;

let value = 42u64;
storage_write(b"my_key", &value.to_le_bytes())?;

pub fn transfer(recipient: &[u8; 32], amount: u64) -> Result<(), u64>;

let recipient = get_tx_sender();
let reward = 100_000000; // 1 TOS (8 decimals)
transfer(&recipient, reward)?;

pub fn transfer_from_contract(recipient: &[u8; 32], amount: u64) -> Result<(), u64>;

pub fn log(message: &str);

log("Transfer successful");

pub fn log_u64(a: u64, b: u64, c: u64, d: u64, e: u64);

log_u64(amount, from_balance, to_balance, 0, 0);

pub fn blake3_hash(data: &[u8]) -> [u8; 32];

let data = b"hello world";
let hash = blake3_hash(data);

pub fn keccak256(data: &[u8]) -> [u8; 32];

pub fn cpi_call(
    target: &[u8; 32],
    input: &[u8],
    return_buffer: &mut [u8],
) -> Result<u32, u64>;

let target_contract = [...]; // 32-byte contract address
let input = [OP_BALANCE_OF, ...]; // Call data
 
let mut return_data = [0u8; 8];
let len = cpi_call(&target_contract, &input, &mut return_data)?;
 
let balance = u64::from_le_bytes(return_data);

pub fn vrf_random(seed: &[u8]) -> Result<VRFOutput, u64>;

pub struct VRFOutput {
    pub random: [u8; 32],      // Random output
    pub pre_output: [u8; 32],  // Pre-output for verification
    pub proof: [u8; 64],       // VRF proof
}

let seed = get_block_hash();
let output = vrf_random(&seed)?;
 
// Use first byte for game logic
let roll = output.random[0] % 100;

pub fn vrf_verify(
    public_key: &[u8; 32],
    input: &[u8; 32],
    pre_output: &[u8; 32],
    proof: &[u8; 64],
) -> Result<(), u64>;

pub fn vrf_public_key() -> Result<[u8; 32], u64>;

pub fn tos_has_referrer(user: &[u8; 32]) -> Result<bool, u64>;

pub fn tos_get_referrer(user: &[u8; 32]) -> Result<[u8; 32], u64>;

pub fn get_uplines(
    user: &[u8; 32],
    levels: u8,
) -> Result<([[u8; 32]; 20], u8), u64>;

let (uplines, count) = get_uplines(&buyer, 3)?;
 
for i in 0..count as usize {
    let upline = &uplines[i];
    // Distribute reward to upline
}

pub fn tos_get_team_size(user: &[u8; 32]) -> Result<u64, u64>;

pub fn add_team_volume(
    user: &[u8; 32],
    asset: &[u8; 32],
    amount: u64,
    levels: u8,
) -> Result<(), u64>;

pub fn get_team_volume(
    user: &[u8; 32],
    asset: &[u8; 32],
) -> Result<u64, u64>;

pub fn get_direct_volume(
    user: &[u8; 32],
    asset: &[u8; 32],
) -> Result<u64, u64>;

pub fn get_zone_volumes(
    user: &[u8; 32],
    asset: &[u8; 32],
    limit: u8,
) -> Result<ZoneVolumesResult, u64>;

#![no_std]
#![no_main]
 
use tako_sdk::*;
 
const KEY_BALANCE: u8 = 0x10;
 
fn get_balance(account: &[u8; 32]) -> u64 {
    let mut key = [0u8; 33];
    key[0] = KEY_BALANCE;
    key[1..33].copy_from_slice(account);
 
    let mut buffer = [0u8; 8];
    let len = storage_read(&key, &mut buffer);
 
    if len == 8 {
        u64::from_le_bytes(buffer)
    } else {
        0
    }
}
 
fn set_balance(account: &[u8; 32], amount: u64) {
    let mut key = [0u8; 33];
    key[0] = KEY_BALANCE;
    key[1..33].copy_from_slice(account);
 
    let _ = storage_write(&key, &amount.to_le_bytes());
}
 
#[no_mangle]
pub extern "C" fn entrypoint() -> u64 {
    let sender = get_tx_sender();
    let deposit = get_call_value();
 
    if deposit > 0 {
        let current = get_balance(&sender);
        let new_balance = current.saturating_add(deposit);
        set_balance(&sender, new_balance);
        log("Deposit successful");
    }
 
    SUCCESS
}
 
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}