Smart Contracts Overview

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add WASM target
rustup target add wasm32-unknown-unknown

nexus dev scaffold my_contract --template basic
cd my_contract

cargo build --target wasm32-unknown-unknown --release

nexus contract deploy \
  --wasm ./target/wasm32-unknown-unknown/release/my_contract.wasm \
  --name my_contract \
  --from my-wallet

use nexus_sdk::{
    solidity::{*, SafeMath},
    contract_api::{ez::prelude::*, ez::ret},
    require,
};
use nexus_sdk::solidity::uint256 as U256;

// State variables using Solidity-compatible Mappings
static BALANCES: Mapping<Address, U256> = Mapping::new(b"bal");
static OWNER: Mapping<&[u8], Address> = Mapping::new(b"owner");

// Initialize contract
nexus_fn! {
    fn init(initial_value: U256) {
        let sender = Blockchain::msg.sender();
        OWNER.set(&b"val".as_slice(), sender.clone());
        BALANCES.set(&sender, initial_value);
        ret::u32(1)
    }
}

// Public function with reentrancy protection
nexus_fn! {
    fn transfer(to: Address, amount: U256) {
        let _guard = ReentrancyGuard::new();
        let sender = Blockchain::msg.sender();
        
        let sender_bal = BALANCES.get(&sender);
        require!(sender_bal >= amount, "Insufficient balance");
        
        BALANCES.set(&sender, sender_bal.sub(amount));
        let to_bal = BALANCES.get(&to);
        BALANCES.set(&to, to_bal.add(amount));
        
        emit("Transfer", &[]);
        ret::u32(1)
    }
}

// View function
nexus_fn! {
    fn balanceOf(addr: Address) {
        let bal = BALANCES.get(&addr);
        let mut out = [0u8; 32];
        bal.to_little_endian(&mut out);
        ret::u256(&out)
    }
}

use nexus_sdk::solidity::{*, SafeMath};
use nexus_sdk::solidity::uint256 as U256;

// Single-key mapping
static BALANCES: Mapping<Address, U256> = Mapping::new(b"bal");

// Double-key mapping (like mapping(address => mapping(address => uint)))
static ALLOWANCES: DoubleMapping<Address, Address, U256> = DoubleMapping::new(b"allow");

// Usage
let balance = BALANCES.get(&addr);
BALANCES.set(&addr, new_balance);

let allowance = ALLOWANCES.get(&owner, &spender);
ALLOWANCES.set(&owner, &spender, amount);

// Safe arithmetic that reverts on overflow
let sum = a.add(b);
let diff = a.sub(b);
let product = a.mul(b);
let quotient = a.div(b);

nexus_fn! {
    fn sensitive_operation() {
        let _guard = ReentrancyGuard::new();  // Auto-releases on drop
        // ... protected logic
    }
}

use nexus_sdk::contract_api::xcc;

// Call another contract
let result = xcc::call(&token_address.0, "balanceOf", &args);

// Deploy a new contract
let new_addr = xcc::deploy(bytecode, init_args, salt);

// Get caller address
let sender = Blockchain::msg.sender();

// Get sent value (for payable functions)
let value = Blockchain::msg.value();

// Get block info
let timestamp = Blockchain::block.timestamp();