Frequently Asked Questions

// Energy efficiency comparison
const energyComparison = {
  bitcoin: {
    energyPerTransaction: "700 kWh",
    utilization: "Single-purpose mining",
    wasteHeat: "100% wasted"
  },
  tosNetwork: {
    energyPerTransaction: "0.15 kWh",
    utilization: "Mining + AI research",
    wasteHeat: "Minimal (efficient algorithms)"
  }
};

#![no_std]
#![no_main]
use tako_sdk::*;
 
#[no_mangle]
pub extern "C" fn entrypoint() -> u64 {
    match get_method().as_str() {
        "transfer" => transfer(),
        "balance_of" => balance_of(),
        _ => ERROR_INVALID_METHOD
    }
}
 
fn transfer() -> u64 {
    let args = get_args();
    let to = &args[0..32];
    let amount = u64::from_le_bytes(args[32..40].try_into().unwrap());
 
    // Update balances...
    SUCCESS
}
 
fn balance_of() -> u64 {
    let account = &get_args()[0..32];
    let mut balance = [0u8; 8];
    storage_read(&[b"balance:", account].concat(), &mut balance);
    set_return_data(&balance);
    SUCCESS
}

// src/lib.rs
#![no_std]
#![no_main]
use tako_sdk::*;
 
#[no_mangle]
pub extern "C" fn entrypoint() -> u64 {
    // Contract implementation
    SUCCESS
}

# Build with Cargo
cargo build --release --target wasm32-unknown-unknown

# Deploy to testnet
tos deploy \
  --contract target/wasm32-unknown-unknown/release/my_contract.wasm \
  --network testnet \
  --gas-limit 1000000
 
# Deploy to mainnet
tos deploy \
  --contract target/wasm32-unknown-unknown/release/my_contract.wasm \
  --network mainnet \
  --constructor-args "1000000" \
  --gas-limit 1000000

// Using SDK
const contract = await tos.contracts.at(contractAddress);
const result = await contract.methods.myMethod().call();
console.log('Contract deployed successfully:', result);

pub struct GasPrices {
    pub base_fee: u64,           // 21,000 gas
    pub contract_creation: u64,   // 32,000 gas
    pub contract_call: u64,      // 21,000 + execution
    pub storage_write: u64,      // 20,000 gas per 32 bytes
    pub storage_read: u64,       // 800 gas per read
}
 
impl Default for GasPrices {
    fn default() -> Self {
        Self {
            base_fee: 21000,
            contract_creation: 32000,
            contract_call: 21000,
            storage_write: 20000,
            storage_read: 800,
        }
    }
}

import { TOSNetwork } from '@tos-network/sdk';
 
const tos = new TOSNetwork('https://rpc.tos.network');
 
// Connect to deployed contract
const contract = tos.contract({
  address: '0x742d35Cc6634C0532925a3b8D09...0b1e3e0',
  abi: contractABI
});
 
// Read from contract (free)
const balance = await contract.methods.balanceOf(userAddress).call();
 
// Write to contract (requires gas)
const txHash = await contract.methods.transfer(
  recipientAddress,
  amount
).send({
  from: userAddress,
  gas: 100000
});

from tos_network import TOSNetwork
 
tos = TOSNetwork('https://rpc.tos.network')
 
# Load contract
contract = tos.contract(
    address='0x742d35Cc6634C0532925a3b8D09...0b1e3e0',
    abi=contract_abi
)
 
# Call contract method
balance = contract.functions.balanceOf(user_address).call()
 
# Send transaction
tx_hash = contract.functions.transfer(
    recipient_address,
    amount
).transact({'from': user_address, 'gas': 100000})

// Get network status
const response = await fetch('https://api.tos.network/v1/daemon/status');
const status = await response.json();
 
console.log(`Block height: ${status.block_height}`);
console.log(`Network hashrate: ${status.hashrate}`);

npm install @tos-network/sdk
# or
pip install tos-network-sdk

import { TOSNetwork } from '@tos-network/sdk';
 
const tos = new TOSNetwork({
  rpcUrl: 'https://rpc.tos.network',
  networkId: 1, // Mainnet
  apiKey: 'your-api-key' // Optional for rate limiting
});

// Check balance
const balance = await tos.wallet.getBalance(userAddress);
 
// Send transaction
const txHash = await tos.wallet.sendTransaction({
  to: recipientAddress,
  amount: '10.5',
  from: userAddress,
  privateKey: userPrivateKey
});
 
// Monitor transaction
const receipt = await tos.waitForTransaction(txHash);

// MetaMask integration
if (window.ethereum) {
  await window.ethereum.request({
    method: 'wallet_addEthereumChain',
    params: [{
      chainId: '0x1', // TOS Network chain ID
      chainName: 'TOS Network',
      rpcUrls: ['https://rpc.tos.network'],
      nativeCurrency: {
        name: 'TOS',
        symbol: 'TOS',
        decimals: 18
      }
    }]
  });
}
 
// WalletConnect integration
import WalletConnect from '@walletconnect/client';
 
const connector = new WalletConnect({
  bridge: 'https://bridge.walletconnect.org',
  qrcodeModal: QRCodeModal,
});
 
if (!connector.connected) {
  connector.createSession();
}

// Check recommended gas price
const gasPrice = await tos.getGasPrice();
 
// Resubmit with higher gas price
const newTxHash = await tos.wallet.sendTransaction({
  ...originalTx,
  gasPrice: gasPrice * 1.2 // 20% higher
});

# Check network status
curl https://api.tos.network/v1/daemon/status
 
# Look for:
# - High mempool size
# - Slow block times
# - Network congestion indicators

// Get current nonce
const nonce = await tos.getTransactionCount(userAddress);
 
// Reset transaction with correct nonce
const txHash = await tos.wallet.sendTransaction({
  ...originalTx,
  nonce: nonce
});

// Common fix: Import missing dependencies
import tos.contract.Contract;
import tos.contract.annotations.*;
import java.math.BigInteger;
 
// Ensure proper inheritance
public class MyContract extends Contract {
    // Implementation
}

// Manual gas estimation
const gasEstimate = await contract.methods.myMethod().estimateGas();
const gasLimit = Math.floor(gasEstimate * 1.2); // 20% buffer
 
const txHash = await contract.methods.myMethod().send({
  from: userAddress,
  gas: gasLimit
});

# Correct parameter encoding
tos-cli deploy MyContract.class \
  --constructor-args "1000000,\"TokenName\",\"TKN\"" \
  --gas-limit 2000000

// Before: Inefficient loop
for (int i = 0; i < users.length; i++) {
    if (users[i].isActive()) {
        processUser(users[i]);
    }
}
 
// After: Optimized with early exit
for (User user : users) {
    if (!user.isActive()) continue;
    processUser(user);
    if (processedCount >= maxProcessing) break;
}

// Estimate gas before sending
const gasEstimate = await contract.methods.complexOperation().estimateGas({
  from: userAddress
});
 
// Add 20% buffer for safety
const gasLimit = Math.floor(gasEstimate * 1.2);

// Instead of multiple transactions
public void batchTransfer(Address[] recipients, BigInteger[] amounts) {
    require(recipients.length == amounts.length, "Array length mismatch");
 
    for (int i = 0; i < recipients.length; i++) {
        transfer(recipients[i], amounts[i]);
    }
}

// Stake TOS for governance participation
const stakeTx = await tos.governance.stake({
  amount: '1000', // TOS tokens
  duration: 90,   // days
  delegate: null  // or delegate address
});
 
// Voting power calculation
const votingPower = await tos.governance.getVotingPower(userAddress);
// Returns: { power: 1500, multiplier: 1.5, duration: 90 }

// Vote on proposal
const voteTx = await tos.governance.vote({
  proposalId: 'TIP-2024-001',
  choice: 'yes', // 'yes', 'no', 'abstain'
  reason: 'This improves network efficiency'
});
 
// Create proposal (requires minimum stake)
const proposalTx = await tos.governance.createProposal({
  title: 'Increase Block Size Limit',
  description: 'Proposal to increase block size from 2MB to 4MB',
  type: 'parameter_change',
  changes: { maxBlockSize: '4MB' }
});

const securityStats = {
  activeNodes: 15420,
  hashRate: '125.5 PH/s',
  uptimePercentage: 99.97,
  securityBudget: '$2.3M/year',
  lastSecurityIncident: 'None reported',
  auditScore: '96.8/100'
};

// Send private transaction
const privateTx = await tos.privacy.sendConfidential({
  to: recipientAddress,
  amount: '10.5',
  memo: 'encrypted memo',
  privacyLevel: 'high'
});

// Ring signature implementation
pub struct RingTransaction {
    pub inputs: Vec<RingInput>,
    pub outputs: Vec<Output>,
    pub ring_signature: RingSignature,
    pub key_image: KeyImage,
}

// Generate stealth address
const stealthAddr = await tos.privacy.generateStealthAddress(
  publicViewKey,
  publicSpendKey
);

// Ledger integration example
import TransportWebUSB from '@ledgerhq/hw-transport-webusb';
import { TOSLedgerApp } from '@tos-network/ledger';
 
const transport = await TransportWebUSB.create();
const ledger = new TOSLedgerApp(transport);
 
// Sign transaction with Ledger
const signature = await ledger.signTransaction(transaction);

// Create 2-of-3 multisig wallet
const multisig = await tos.wallet.createMultiSig({
  owners: [owner1, owner2, owner3],
  threshold: 2,
  timelock: 86400 // 24 hours
});

# Backup wallet securely
tos-cli wallet backup \
  --output encrypted_backup.json \
  --password secure_password
 
# Store backup in multiple secure locations
# Never store password with backup file

// iOS Swift example
import TOSNetworkSDK
 
let wallet = TOSWallet()
let balance = try await wallet.getBalance(address: userAddress)
print("Balance: \(balance) TOS")

// Android Kotlin example
import network.tos.sdk.*
 
val wallet = TOSWallet()
val balance = wallet.getBalance(userAddress)
println("Balance: $balance TOS")

// Provide liquidity to TOSSwap
const liquidityTx = await tosSwap.addLiquidity({
  tokenA: 'TOS',
  tokenB: 'USDT',
  amountA: '1000',
  amountB: '500',
  slippage: 0.5
});
 
// Start yield farming
const farmTx = await tosFarm.stake({
  poolId: 'TOS-USDT-LP',
  amount: lpTokenBalance,
  lockPeriod: 30 // days
});

# Join contributor onboarding
git clone https://github.com/tos-network/contributors
cd contributors
./onboarding-script.sh
 
# or join Discord
# discord.tos.network #contributors-welcome