Skip to Content
Getting StartedSmart Contract Development

Smart Contract Development on TOS Network

Welcome to smart contract development on TOS Network! This comprehensive guide will teach you how to build, deploy, and manage smart contracts using Java 8 syntax powered by the Rust Virtual Machine (RVM). Experience the familiar comfort of Java development with the performance and security of Rust execution.

Why TOS Network for Smart Contracts?

Java 8 Compatibility

  • Familiar Syntax: Use Java 8 that millions of developers already know
  • Rich Ecosystem: Leverage existing Java libraries and patterns
  • Enterprise Ready: Production-grade language for serious applications
  • No Learning Curve: Start building immediately with existing skills

Rust Virtual Machine (RVM)

  • High Performance: Rust-based execution for maximum speed
  • Memory Safety: Zero-cost abstractions with guaranteed safety
  • Concurrent Execution: Native support for parallel smart contract execution
  • Security First: Comprehensive sandboxing and isolation

Privacy Integration

  • Confidential Contracts: Execute smart contracts with private inputs
  • Encrypted State: Store sensitive data with homomorphic encryption
  • Zero-Knowledge Integration: Generate and verify cryptographic proofs
  • Private Transactions: Interact with contracts while maintaining privacy

TOS Network Features

  • Energy Payments: Use staked TOS energy for gas-free contract execution
  • BlockDAG Integration: Parallel contract execution across multiple blocks
  • AI-Mining Integration: Smart contracts can publish and consume AI tasks
  • Advanced Cryptography: Built-in support for privacy-preserving operations

Development Environment Setup

Prerequisites

Before starting, ensure you have:

  • Java Development Kit (JDK) 8+
  • Maven or Gradle for dependency management
  • Git for version control
  • TOS Network CLI for deployment and interaction

Install TOS Development Tools

# Install TOS CLI
curl -fsSL https://install.tos.network | bash
source ~/.bashrc
 
# Verify installation
tos version
# Expected output: TOS CLI v1.0.0
 
# Install TOS Smart Contract SDK
npm install -g @tos-network/contract-cli

Create Development Project

# Create new smart contract project
tos create-contract --name MyFirstContract --template basic
cd MyFirstContract
 
# Project structure
MyFirstContract/
├── src/
│   └── main/
│       └── java/
│           └── com/
│               └── example/
│                   └── MyFirstContract.java
├── contracts/
│   └── examples/
├── tests/
├── pom.xml
├── tos-config.json
└── README.md

Configure Development Environment

// tos-config.json
{
  "network": "testnet",
  "compiler": {
    "java_version": "8",
    "optimization_level": "standard",
    "debug_symbols": true
  },
  "deployment": {
    "gas_limit": 1000000,
    "energy_limit": 500000,
    "auto_verify": true
  },
  "privacy": {
    "confidential_state": false,
    "encrypted_inputs": false,
    "zero_knowledge_proofs": false
  }
}

Your First Smart Contract

Basic Token Contract

Let’s create a simple token contract to understand TOS smart contract development:

package com.example;
 
import com.tosnetwork.contract.*;
import com.tosnetwork.contract.annotations.*;
import com.tosnetwork.contract.types.*;
import java.util.Map;
import java.util.HashMap;
 
@Contract
public class SimpleToken {
 
    // State variables
    @State
    private String name;
 
    @State
    private String symbol;
 
    @State
    private long totalSupply;
 
    @State
    private Map<Address, Long> balances;
 
    @State
    private Map<Address, Map<Address, Long>> allowances;
 
    // Events
    @Event
    public static class Transfer {
        @Indexed
        public Address from;
 
        @Indexed
        public Address to;
 
        public long amount;
 
        public Transfer(Address from, Address to, long amount) {
            this.from = from;
            this.to = to;
            this.amount = amount;
        }
    }
 
    @Event
    public static class Approval {
        @Indexed
        public Address owner;
 
        @Indexed
        public Address spender;
 
        public long amount;
 
        public Approval(Address owner, Address spender, long amount) {
            this.owner = owner;
            this.spender = spender;
            this.amount = amount;
        }
    }
 
    // Constructor
    @Constructor
    public void init(String name, String symbol, long initialSupply) {
        this.name = name;
        this.symbol = symbol;
        this.totalSupply = initialSupply;
        this.balances = new HashMap<>();
        this.allowances = new HashMap<>();
 
        // Assign all tokens to contract deployer
        Address deployer = Context.getCaller();
        balances.put(deployer, initialSupply);
 
        // Emit initial transfer event
        emit(new Transfer(Address.ZERO, deployer, initialSupply));
    }
 
    // Public view functions
    @View
    public String getName() {
        return name;
    }
 
    @View
    public String getSymbol() {
        return symbol;
    }
 
    @View
    public long getTotalSupply() {
        return totalSupply;
    }
 
    @View
    public long balanceOf(Address account) {
        return balances.getOrDefault(account, 0L);
    }
 
    @View
    public long allowance(Address owner, Address spender) {
        return allowances.getOrDefault(owner, new HashMap<>())
                         .getOrDefault(spender, 0L);
    }
 
    // Public functions
    @Public
    public boolean transfer(Address to, long amount) {
        Address from = Context.getCaller();
        return _transfer(from, to, amount);
    }
 
    @Public
    public boolean approve(Address spender, long amount) {
        Address owner = Context.getCaller();
 
        // Update allowance
        allowances.computeIfAbsent(owner, k -> new HashMap<>())
                  .put(spender, amount);
 
        // Emit approval event
        emit(new Approval(owner, spender, amount));
 
        return true;
    }
 
    @Public
    public boolean transferFrom(Address from, Address to, long amount) {
        Address caller = Context.getCaller();
 
        // Check allowance
        long currentAllowance = allowance(from, caller);
        require(currentAllowance >= amount, "Insufficient allowance");
 
        // Update allowance
        allowances.get(from).put(caller, currentAllowance - amount);
 
        // Perform transfer
        return _transfer(from, to, amount);
    }
 
    // Internal functions
    private boolean _transfer(Address from, Address to, long amount) {
        require(!to.equals(Address.ZERO), "Cannot transfer to zero address");
        require(amount > 0, "Amount must be positive");
 
        long fromBalance = balanceOf(from);
        require(fromBalance >= amount, "Insufficient balance");
 
        // Update balances
        balances.put(from, fromBalance - amount);
        balances.put(to, balanceOf(to) + amount);
 
        // Emit transfer event
        emit(new Transfer(from, to, amount));
 
        return true;
    }
 
    // Utility functions
    private void require(boolean condition, String message) {
        if (!condition) {
            revert(message);
        }
    }
 
    private void revert(String message) {
        throw new ContractException(message);
    }
 
    private void emit(Object event) {
        Context.emitEvent(event);
    }
}

Understanding the Contract Structure

Annotations Explained

@Contract              // Marks class as smart contract
@State                // Persistent state variable
@Constructor          // Contract initialization function
@Public               // Publicly callable function
@View                 // Read-only function (no state changes)
@Event                // Event definition
@Indexed              // Indexed event parameter for filtering

TOS-Specific Features

// TOS Network Context API
Address caller = Context.getCaller();           // Transaction sender
Address contractAddress = Context.getAddress(); // This contract's address
long blockHeight = Context.getBlockHeight();    // Current block height
long timestamp = Context.getTimestamp();        // Block timestamp
long energyRemaining = Context.getEnergyLeft(); // Remaining energy units
 
// Privacy features (if enabled)
EncryptedValue encryptedAmount = Context.encrypt(amount);
ZKProof proof = Context.generateProof(secret, public_input);
boolean isValid = Context.verifyProof(proof);

Advanced Smart Contract Features

Privacy-Preserving Contracts

@Contract
@PrivacyEnabled
public class PrivateAuction {
 
    @State
    @Encrypted
    private Map<Address, EncryptedValue> bids;
 
    @State
    private Address highestBidder;
 
    @State
    @Encrypted
    private EncryptedValue highestBid;
 
    @State
    private long auctionEndTime;
 
    @Constructor
    public void init(long durationMinutes) {
        this.auctionEndTime = Context.getTimestamp() + (durationMinutes * 60);
        this.bids = new HashMap<>();
        this.highestBid = EncryptedValue.zero();
    }
 
    @Public
    @PrivateInputs
    public void placeBid(@Encrypted long bidAmount, ZKProof validityProof) {
        require(Context.getTimestamp() < auctionEndTime, "Auction ended");
        require(Context.verifyProof(validityProof), "Invalid proof");
 
        Address bidder = Context.getCaller();
        EncryptedValue encryptedBid = Context.encrypt(bidAmount);
 
        // Store encrypted bid
        bids.put(bidder, encryptedBid);
 
        // Update highest bid using homomorphic comparison
        if (encryptedBid.isGreaterThan(highestBid)) {
            highestBid = encryptedBid;
            highestBidder = bidder;
        }
 
        emit(new BidPlaced(bidder, encryptedBid));
    }
 
    @Public
    public void revealWinner() {
        require(Context.getTimestamp() >= auctionEndTime, "Auction still active");
        require(highestBidder != null, "No bids placed");
 
        // Reveal winner (amount stays encrypted)
        emit(new AuctionEnded(highestBidder, highestBid));
    }
 
    @Event
    public static class BidPlaced {
        @Indexed
        public Address bidder;
 
        @Encrypted
        public EncryptedValue bid;
 
        public BidPlaced(Address bidder, EncryptedValue bid) {
            this.bidder = bidder;
            this.bid = bid;
        }
    }
}

Energy-Optimized Contracts

@Contract
@EnergyOptimized
public class EnergyEfficientVoting {
 
    @State
    private Map<String, Proposal> proposals;
 
    @State
    private Map<Address, Map<String, Boolean>> hasVoted;
 
    @Public
    @EnergyPriority("low")  // Use energy instead of gas when possible
    public void createProposal(String proposalId, String description) {
        require(!proposals.containsKey(proposalId), "Proposal already exists");
 
        proposals.put(proposalId, new Proposal(
            proposalId,
            description,
            Context.getCaller(),
            Context.getTimestamp(),
            0L  // vote count
        ));
 
        emit(new ProposalCreated(proposalId, description));
    }
 
    @Public
    @EnergyPriority("high")  // Prefer energy for frequent operations
    public void vote(String proposalId, boolean support) {
        require(proposals.containsKey(proposalId), "Proposal not found");
 
        Address voter = Context.getCaller();
        require(!hasVoted.getOrDefault(voter, new HashMap<>())
                         .getOrDefault(proposalId, false),
                "Already voted");
 
        // Record vote
        hasVoted.computeIfAbsent(voter, k -> new HashMap<>())
                .put(proposalId, true);
 
        // Update proposal
        Proposal proposal = proposals.get(proposalId);
        if (support) {
            proposal.voteCount++;
        }
 
        emit(new VoteCast(voter, proposalId, support));
    }
 
    @View
    @EnergyFree  // Read operations don't consume energy
    public Proposal getProposal(String proposalId) {
        return proposals.get(proposalId);
    }
}

AI-Mining Integration

@Contract
public class AITaskMarketplace {
 
    @State
    private Map<String, AITask> tasks;
 
    @State
    private Map<String, Solution> solutions;
 
    @Public
    public void publishTask(
        String taskId,
        String description,
        TaskType taskType,
        long reward,
        long deadline
    ) {
        require(!tasks.containsKey(taskId), "Task already exists");
        require(reward > 0, "Reward must be positive");
        require(deadline > Context.getTimestamp(), "Deadline must be in future");
 
        Address publisher = Context.getCaller();
 
        // Transfer reward to contract as escrow
        TOSToken.transferFrom(publisher, Context.getAddress(), reward);
 
        tasks.put(taskId, new AITask(
            taskId,
            description,
            taskType,
            publisher,
            reward,
            deadline,
            TaskStatus.OPEN
        ));
 
        // Publish to AI-Mining network
        AIMining.publishTask(taskId, description, taskType, reward, deadline);
 
        emit(new TaskPublished(taskId, publisher, reward));
    }
 
    @Public
    public void submitSolution(
        String taskId,
        String solutionData,
        long qualityScore,
        ZKProof qualityProof
    ) {
        require(tasks.containsKey(taskId), "Task not found");
        require(Context.verifyProof(qualityProof), "Invalid quality proof");
 
        AITask task = tasks.get(taskId);
        require(task.status == TaskStatus.OPEN, "Task not open");
        require(Context.getTimestamp() < task.deadline, "Task deadline passed");
 
        Address solver = Context.getCaller();
 
        solutions.put(taskId, new Solution(
            taskId,
            solver,
            solutionData,
            qualityScore,
            Context.getTimestamp()
        ));
 
        emit(new SolutionSubmitted(taskId, solver, qualityScore));
    }
 
    @Public
    public void acceptSolution(String taskId) {
        require(tasks.containsKey(taskId), "Task not found");
        require(solutions.containsKey(taskId), "No solution submitted");
 
        AITask task = tasks.get(taskId);
        require(Context.getCaller().equals(task.publisher), "Only publisher can accept");
 
        Solution solution = solutions.get(taskId);
 
        // Transfer reward to solver
        TOSToken.transfer(solution.solver, task.reward);
 
        // Update task status
        task.status = TaskStatus.COMPLETED;
 
        emit(new TaskCompleted(taskId, solution.solver, task.reward));
    }
}

Testing Smart Contracts

Unit Testing Framework

// Test class using TOS Testing Framework
package com.example.test;
 
import com.tosnetwork.testing.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
 
public class SimpleTokenTest {
 
    private TOSTestEnvironment testEnv;
    private SimpleToken contract;
    private Address deployer;
    private Address user1;
    private Address user2;
 
    @BeforeEach
    public void setup() {
        testEnv = new TOSTestEnvironment();
        deployer = testEnv.createAccount("deployer", 1000000);
        user1 = testEnv.createAccount("user1", 100000);
        user2 = testEnv.createAccount("user2", 100000);
 
        // Deploy contract
        contract = testEnv.deploy(SimpleToken.class, deployer)
                         .withArgs("Test Token", "TEST", 1000000L)
                         .withGasLimit(500000)
                         .execute();
    }
 
    @Test
    public void testInitialState() {
        assertEquals("Test Token", contract.getName());
        assertEquals("TEST", contract.getSymbol());
        assertEquals(1000000L, contract.getTotalSupply());
        assertEquals(1000000L, contract.balanceOf(deployer));
    }
 
    @Test
    public void testTransfer() {
        // Perform transfer
        testEnv.call(contract, deployer)
               .method("transfer")
               .withArgs(user1, 1000L)
               .execute();
 
        // Verify balances
        assertEquals(999000L, contract.balanceOf(deployer));
        assertEquals(1000L, contract.balanceOf(user1));
 
        // Check events
        TransferEvent event = testEnv.getLastEvent(TransferEvent.class);
        assertEquals(deployer, event.from);
        assertEquals(user1, event.to);
        assertEquals(1000L, event.amount);
    }
 
    @Test
    public void testTransferInsufficientBalance() {
        // Try to transfer more than balance
        assertThrows(ContractException.class, () -> {
            testEnv.call(contract, user1)
                   .method("transfer")
                   .withArgs(user2, 1000L)
                   .execute();
        });
    }
 
    @Test
    public void testApproveAndTransferFrom() {
        // Approve user1 to spend tokens
        testEnv.call(contract, deployer)
               .method("approve")
               .withArgs(user1, 500L)
               .execute();
 
        assertEquals(500L, contract.allowance(deployer, user1));
 
        // Transfer from deployer to user2 using user1's allowance
        testEnv.call(contract, user1)
               .method("transferFrom")
               .withArgs(deployer, user2, 300L)
               .execute();
 
        assertEquals(999700L, contract.balanceOf(deployer));
        assertEquals(300L, contract.balanceOf(user2));
        assertEquals(200L, contract.allowance(deployer, user1));
    }
 
    @Test
    public void testEnergyOptimization() {
        // Test energy consumption
        EnergyMeter meter = testEnv.createEnergyMeter();
 
        meter.start();
        testEnv.call(contract, deployer)
               .method("transfer")
               .withArgs(user1, 100L)
               .preferEnergy()  // Use energy instead of gas
               .execute();
        long energyUsed = meter.stop();
 
        assertTrue(energyUsed > 0);
        assertTrue(energyUsed < 50); // Should be efficient
    }
}

Integration Testing

@Test
public void testComplexScenario() {
    // Create a complex multi-contract scenario
    DEXContract dex = testEnv.deploy(DEXContract.class, deployer)
                            .withArgs(contract.getAddress())
                            .execute();
 
    // Add liquidity
    testEnv.call(contract, deployer)
           .method("approve")
           .withArgs(dex.getAddress(), 10000L)
           .execute();
 
    testEnv.call(dex, deployer)
           .method("addLiquidity")
           .withArgs(10000L)
           .withTOSValue(1000000L) // 1 TOS
           .execute();
 
    // Test swap
    long initialBalance = contract.balanceOf(user1);
    testEnv.call(dex, user1)
           .method("swapTOSForTokens")
           .withTOSValue(100000L) // 0.1 TOS
           .execute();
 
    assertTrue(contract.balanceOf(user1) > initialBalance);
}

Deployment and Management

Deploy to Testnet

# Compile contract
tos compile src/main/java/com/example/SimpleToken.java
 
# Deploy to testnet
tos deploy SimpleToken \
    --network testnet \
    --args "My Token,MTK,1000000" \
    --gas-limit 1000000 \
    --from 0xYourAddress
 
# Example output:
Contract deployed successfully!
Address: tos1contract-address-here...
Transaction: 0xtxhash...
Gas used: 847,293
Deployment cost: 0.847 TOS

Verify Contract

# Verify contract source code
tos verify SimpleToken \
    --address tos1contract-address-here... \
    --source src/main/java/com/example/SimpleToken.java \
    --args "My Token,MTK,1000000"
 
# Contract verification successful!
# Explorer link: https://testnet-explorer.tos.network/contract/tos1contract-address-here...

Interact with Deployed Contract

// Using TOS JavaScript SDK
const { TOSNetwork } = require('@tos-network/sdk');
 
const tos = new TOSNetwork({
    network: 'testnet',
    privateKey: 'your-private-key'
});
 
// Load contract
const contract = tos.contract(
    'SimpleToken',
    'tos1contract-address-here...'
);
 
// Call view functions
const balance = await contract.balanceOf('tos1user-address...');
console.log('Balance:', balance);
 
// Execute transactions
const tx = await contract.transfer(
    'tos1recipient-address...',
    1000,
    { energyLimit: 100000 }
);
 
console.log('Transaction hash:', tx.hash);
await tx.wait(); // Wait for confirmation

Contract Monitoring

// Monitor contract events
contract.on('Transfer', (from, to, amount, event) => {
    console.log(`Transfer: ${from} -> ${to}: ${amount}`);
    console.log('Block:', event.blockNumber);
    console.log('Transaction:', event.transactionHash);
});
 
// Monitor all events
contract.on('*', (eventName, event) => {
    console.log(`Event ${eventName}:`, event);
});
 
// Get historical events
const transfers = await contract.queryFilter(
    contract.filters.Transfer(),
    startBlock,
    endBlock
);

Best Practices and Security

Security Guidelines

Input Validation

@Public
public void withdraw(long amount) {
    require(amount > 0, "Amount must be positive");
    require(amount <= balances.get(Context.getCaller()), "Insufficient balance");
    require(amount <= address(this).balance, "Insufficient contract balance");
 
    // Checks-Effects-Interactions pattern
    balances.put(Context.getCaller(), balances.get(Context.getCaller()) - amount);
    Context.transfer(Context.getCaller(), amount);
}

Reentrancy Protection

@State
private boolean locked = false;
 
@Modifier
public void nonReentrant() {
    require(!locked, "Reentrant call");
    locked = true;
 
    // Function execution happens here
 
    locked = false;
}
 
@Public
@nonReentrant
public void sensitiveFunction() {
    // Protected against reentrancy
}

Access Control

@State
private Address owner;
 
@State
private Map<Address, Boolean> admins;
 
@Modifier
public void onlyOwner() {
    require(Context.getCaller().equals(owner), "Not owner");
}
 
@Modifier
public void onlyAdmin() {
    require(admins.getOrDefault(Context.getCaller(), false), "Not admin");
}
 
@Public
@onlyOwner
public void setAdmin(Address admin, boolean isAdmin) {
    admins.put(admin, isAdmin);
}

Performance Optimization

Gas Optimization

// Efficient storage patterns
@State
private Map<Address, UserInfo> users; // Struct packing
 
public static class UserInfo {
    public long balance;
    public long lastActivity;
    public boolean isActive;
 
    // Pack multiple values in single storage slot
}
 
// Batch operations
@Public
public void batchTransfer(Address[] recipients, long[] amounts) {
    require(recipients.length == amounts.length, "Array length mismatch");
 
    for (int i = 0; i < recipients.length; i++) {
        _transfer(Context.getCaller(), recipients[i], amounts[i]);
    }
}

Energy Optimization

@Public
@EnergyOptimized
public void energyEfficientFunction() {
    // Use minimal state changes
    // Prefer local variables over state variables
    // Cache frequently accessed state
 
    long cachedValue = expensiveStateVariable; // Cache once
 
    for (int i = 0; i < 100; i++) {
        // Use cached value instead of accessing state repeatedly
        processValue(cachedValue);
    }
}

Testing Strategies

Comprehensive Test Coverage

@Test
public void testEdgeCases() {
    // Test boundary conditions
    testTransferZeroAmount();
    testTransferMaxAmount();
    testTransferToSelf();
    testTransferToZeroAddress();
 
    // Test overflow conditions
    testOverflowProtection();
    testUnderflowProtection();
 
    // Test access control
    testUnauthorizedAccess();
    testOwnershipTransfer();
}
 
@Test
public void testGasConsumption() {
    GasMeter meter = testEnv.createGasMeter();
 
    // Measure gas for different operations
    long transferGas = meter.measure(() ->
        contract.transfer(user1, 1000L)
    );
 
    long approveGas = meter.measure(() ->
        contract.approve(user1, 1000L)
    );
 
    // Assert gas consumption is within expected limits
    assertTrue(transferGas < 100000);
    assertTrue(approveGas < 50000);
}

Advanced Topics

Cross-Contract Communication

@Contract
public class TokenFactory {
 
    @State
    private Address[] deployedTokens;
 
    @Public
    public Address createToken(String name, String symbol, long supply) {
        // Deploy new token contract
        SimpleToken newToken = new SimpleToken();
        newToken.init(name, symbol, supply);
 
        Address tokenAddress = newToken.getAddress();
        deployedTokens.push(tokenAddress);
 
        emit(new TokenCreated(tokenAddress, name, symbol, supply));
 
        return tokenAddress;
    }
 
    @View
    public long getTotalTokenBalance(Address user) {
        long totalBalance = 0;
 
        for (Address tokenAddr : deployedTokens) {
            SimpleToken token = SimpleToken.at(tokenAddr);
            totalBalance += token.balanceOf(user);
        }
 
        return totalBalance;
    }
}

Upgradeable Contracts

@Contract
@Upgradeable
public class UpgradeableToken {
 
    @State
    @Immutable
    private Address proxyContract;
 
    @State
    private uint256 version;
 
    @Public
    @onlyOwner
    public void upgrade(Address newImplementation) {
        require(newImplementation != address(0), "Invalid implementation");
 
        // Validate new implementation
        require(isValidImplementation(newImplementation), "Invalid implementation");
 
        // Update proxy to point to new implementation
        Proxy(proxyContract).upgrade(newImplementation);
 
        version++;
        emit(new ContractUpgraded(newImplementation, version));
    }
 
    @View
    public uint256 getVersion() {
        return version;
    }
}

Oracle Integration

@Contract
public class PriceOracle {
 
    @State
    private Map<String, PriceData> prices;
 
    @State
    private Map<Address, Boolean> oracles;
 
    @Public
    @onlyOracle
    public void updatePrice(String asset, long price, long timestamp) {
        require(price > 0, "Invalid price");
        require(timestamp > prices.get(asset).timestamp, "Stale data");
 
        prices.put(asset, new PriceData(price, timestamp, Context.getCaller()));
 
        emit(new PriceUpdated(asset, price, timestamp));
    }
 
    @View
    public long getPrice(String asset) {
        PriceData data = prices.get(asset);
        require(data != null, "Price not available");
        require(Context.getTimestamp() - data.timestamp < 3600, "Price too old");
 
        return data.price;
    }
}

Deployment Strategies

Mainnet Deployment Checklist

# Pre-deployment checklist
□ Comprehensive testing completed
□ Security audit performed
□ Gas optimization verified
□ Access controls reviewed
□ Error handling tested
□ Documentation complete
□ Monitoring setup prepared
 
# Deployment script
#!/bin/bash
 
# 1. Final compilation
echo "Compiling contracts..."
tos compile --optimize
 
# 2. Deploy to mainnet
echo "Deploying to mainnet..."
tos deploy MyContract \
    --network mainnet \
    --args "constructor,args,here" \
    --gas-limit 2000000 \
    --gas-price 20 \
    --confirm
 
# 3. Verify contract
echo "Verifying contract..."
tos verify MyContract \
    --address $CONTRACT_ADDRESS \
    --args "constructor,args,here"
 
# 4. Setup monitoring
echo "Setting up monitoring..."
tos monitor setup \
    --contract $CONTRACT_ADDRESS \
    --events Transfer,Approval \
    --webhook https://your-monitoring-service.com/webhook
 
echo "Deployment complete!"

Multi-Environment Management

// environments.json
{
  "development": {
    "network": "localhost",
    "gas_price": 1,
    "confirmations": 1,
    "timeout": 30000
  },
  "testnet": {
    "network": "tos-testnet",
    "gas_price": 10,
    "confirmations": 6,
    "timeout": 60000
  },
  "mainnet": {
    "network": "tos-mainnet",
    "gas_price": 20,
    "confirmations": 12,
    "timeout": 120000
  }
}

Troubleshooting and Debugging

Common Issues and Solutions

Contract Compilation Errors

# Error: Cannot find symbol
# Solution: Check imports and class path
javac -cp "lib/*:src/" src/main/java/com/example/MyContract.java
 
# Error: Annotation not found
# Solution: Include TOS contract annotations
import com.tosnetwork.contract.annotations.*;

Deployment Failures

# Error: Out of gas
# Solution: Increase gas limit
tos deploy MyContract --gas-limit 3000000
 
# Error: Insufficient balance
# Solution: Add funds to deployer account
tos account fund --amount 10 --to 0xYourAddress

Runtime Errors

// Debug contract execution
@Public
public void debugFunction(long input) {
    emit(new DebugEvent("Function called", input));
 
    try {
        riskyOperation(input);
        emit(new DebugEvent("Operation succeeded", input));
    } catch (Exception e) {
        emit(new DebugEvent("Operation failed", e.getMessage()));
        revert("Operation failed: " + e.getMessage());
    }
}

Performance Profiling

// Profile contract performance
const profiler = new ContractProfiler(contract);
 
await profiler.profile('transfer', async () => {
    await contract.transfer(recipient, amount);
});
 
const report = profiler.getReport();
console.log('Gas used:', report.gasUsed);
console.log('Energy used:', report.energyUsed);
console.log('Execution time:', report.executionTime);

Resources and Next Steps

Documentation Resources

  • TOS Network Docs: Complete platform documentation
  • Java 8 Reference: Oracle Java documentation
  • RVM Specification: Rust Virtual Machine details
  • Contract Examples: Open-source contract library

Development Tools

  • TOS CLI: Command-line development tools
  • Contract IDE: Browser-based development environment
  • Testing Framework: Comprehensive testing tools
  • Debugging Tools: Contract debugging and profiling

Community Resources

  • Developer Discord: Real-time help and discussions
  • GitHub Repository: Open-source contracts and tools
  • Stack Overflow: Tagged questions and answers
  • YouTube Tutorials: Video guides and walkthroughs

Sample Projects

# Clone sample projects
git clone https://github.com/tos-network/contract-examples.git
 
# Available examples:
├── token-contracts/          # ERC20, ERC721, custom tokens
├── defi-protocols/          # DEX, lending, staking
├── gaming-contracts/        # NFT games, tournaments
├── dao-governance/          # Voting, proposals, treasury
├── privacy-contracts/       # Confidential computations
└── ai-integration/          # AI-Mining marketplace contracts

Conclusion

Congratulations! You now have a comprehensive understanding of smart contract development on TOS Network. You’ve learned:

  • Java 8 Development: Build contracts using familiar Java syntax
  • RVM Integration: Leverage Rust performance with Java ease
  • Privacy Features: Implement confidential smart contracts
  • Energy Optimization: Build cost-effective applications
  • Security Best Practices: Develop secure, auditable contracts
  • Testing Strategies: Ensure contract reliability and performance

TOS Network’s smart contract platform embodies the principle “Don’t Trust, Verify it” - every contract execution is mathematically verified, cryptographically secure, and transparently auditable.

Start building the next generation of decentralized applications with the power of Java, the performance of Rust, and the privacy of advanced cryptography!

Next Steps

  • Build Your First DApp: Create a complete decentralized application
  1. Join Developer Community: Connect with other TOS developers
  2. Contribute to Ecosystem: Build open-source tools and libraries
  3. Explore Advanced Features: Dive deeper into privacy and AI integration

Remember: “Don’t Trust, Verify it” - Build applications that users can cryptographically verify and mathematically trust!

Last updated on
AI-Mining SetupMining Difficulty