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)"
  }
};

# Image classification task example
task = {
    'type': 'image_classification',
    'dataset': 'medical_xrays',
    'classes': ['normal', 'pneumonia', 'covid19'],
    'images': 1000,
    'target_accuracy': 0.92,
    'reward': 15.5,  # TOS tokens
    'deadline': '2024-10-25T12:00:00Z'
}

budget_setup:
  cpu: "AMD Ryzen 5 5600X"
  ram: "16GB DDR4"
  gpu: "RTX 3060"
  estimated_daily_earnings: "3-5 TOS"
 
performance_setup:
  cpu: "AMD Ryzen 9 7900X"
  ram: "32GB DDR5"
  gpu: "RTX 4080"
  estimated_daily_earnings: "12-18 TOS"
 
professional_setup:
  cpu: "AMD Threadripper PRO"
  ram: "128GB DDR4"
  gpu: "RTX 4090 x2"
  estimated_daily_earnings: "35-50 TOS"

// Daily earnings estimation
function estimateEarnings(hashRate, qualityScore, powerCost) {
  const baseReward = hashRate * 0.0001; // Base mining
  const aiBonus = baseReward * (qualityScore / 10) * 0.3; // AI bonus
  const grossEarnings = baseReward + aiBonus;
  const energyCost = powerCost * 24; // Daily energy cost
 
  return grossEarnings - energyCost;
}
 
// Example: RTX 3080 setup
const dailyEarnings = estimateEarnings(
  120, // TH/s equivalent
  8.5, // Quality score
  0.15 // $0.15/kWh
);
// Result: ~8-12 TOS per day

pub fn calculate_quality_score(
    accuracy: f64,           // 0.0 to 1.0
    efficiency: f64,         // Speed factor
    innovation: f64,         // Algorithm novelty
    consistency: f64         // Historical performance
) -> f64 {
    let weights = [0.4, 0.25, 0.2, 0.15];
    let scores = [accuracy, efficiency, innovation, consistency];
 
    weights.iter()
          .zip(scores.iter())
          .map(|(w, s)| w * s)
          .sum::<f64>()
          .min(10.0)
}

import tos.contract.Contract;
import tos.contract.annotations.*;
 
public class TokenContract extends Contract {
    private Map<Address, BigInteger> balances;
    private BigInteger totalSupply;
 
    @Constructor
    public TokenContract(BigInteger initialSupply) {
        balances = new HashMap<>();
        totalSupply = initialSupply;
        balances.put(getCaller(), initialSupply);
    }
 
    @View
    public BigInteger balanceOf(Address account) {
        return balances.getOrDefault(account, BigInteger.ZERO);
    }
 
    @External
    public boolean transfer(Address to, BigInteger amount) {
        Address from = getCaller();
        require(balanceOf(from).compareTo(amount) >= 0, "Insufficient balance");
 
        balances.put(from, balances.get(from).subtract(amount));
        balances.put(to, balances.getOrDefault(to, BigInteger.ZERO).add(amount));
 
        emit(new TransferEvent(from, to, amount));
        return true;
    }
}

// MyContract.java
public class MyContract extends Contract {
    // Contract implementation
}

# Using TOS CLI
tos-cli compile MyContract.java
 
# Output: MyContract.class (bytecode)

# Deploy to testnet
tos-cli deploy MyContract.class \
  --network testnet \
  --constructor-args "1000000" \
  --gas-limit 1000000
 
# Deploy to mainnet
tos-cli deploy MyContract.class \
  --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
});

# GPU status
nvidia-smi
 
# CPU info
lscpu | grep "Model name"
 
# Memory usage
free -h

# Test RPC connection
curl -X POST https://rpc.tos.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tos_blockNumber","params":[],"id":1}'

# ~/.tos/miner.toml
[ai_mining]
enabled = true
gpu_enabled = true
max_memory_usage = 0.8
worker_threads = 8
 
[network]
rpc_url = "https://rpc.tos.network"
worker_address = "your_wallet_address"

# Check miner logs
tail -f ~/.tos/logs/miner.log
 
# Look for common issues:
# - CUDA initialization errors
# - Network connectivity issues
# - Task downloading failures
# - Quality score problems

// 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]);
    }
}

// TOSSwap (native DEX)
const quote = await tosSwap.getQuote({
  tokenIn: 'USDT',
  tokenOut: 'TOS',
  amountIn: '1000'
});
 
const swapTx = await tosSwap.swap({
  tokenIn: 'USDT',
  tokenOut: 'TOS',
  amountIn: '1000',
  amountOutMin: quote.amountOutMin,
  slippage: 0.5 // 0.5%
});

const marketData = {
  price: '$0.52',
  marketCap: '$4.65M',
  volume24h: '$1.2M',
  circulatingSupply: '8,945,123 TOS',
  maxSupply: '21,000,000 TOS',
  rank: 387,
  priceChange24h: '+12.4%'
};

// 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.gg/tos-network #contributors-welcome