Contract API

[dependencies]
nexus-sdk = { version = "0.1", features = ["contract"] }

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

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

nexus_fn! {
    fn init() {
        let sender = Blockchain::msg.sender();
        OWNER.set(&b"val".as_slice(), sender);
        VALUE.set(&b"val".as_slice(), U256::from(0));
        ret::u32(1)
    }
}

nexus_fn! {
    fn my_function(amount: U256) {
        let _guard = ReentrancyGuard::new();
        let current = VALUE.get(&b"val".as_slice());
        VALUE.set(&b"val".as_slice(), current.add(amount));
        
        let mut out = [0u8; 32];
        current.to_little_endian(&mut out);
        ret::u256(&out)
    }
}

use nexus_sdk::contract_api::storage;

let value = storage::get(b"my_key");
// Returns: Vec<u8> (empty if not found)

storage::set(b"my_key", b"my_value");

storage::remove(b"my_key");

if storage::has(b"my_key") {
    // Key exists
}

use nexus_sdk::contract_api::context;

let caller = context::caller();
// Returns: Vec<u8> (caller's public key)

let self_addr = context::self_address();
// Returns: Vec<u8> (contract ID)

let height = context::block_height();
// Returns: u64

let timestamp = context::block_timestamp();
// Returns: u64 (Unix timestamp)

let origin = context::origin();
// Returns: Vec<u8> (original sender's public key)

use nexus_sdk::contract_api::crypto;

let hash = crypto::sha256(b"hello");
// Returns: [u8; 32]

let hash = crypto::keccak256(b"hello");
// Returns: [u8; 32]

let hash = crypto::blake3(b"hello");
// Returns: [u8; 32]

use nexus_sdk::contract_api::events;

events::emit("Transfer", &transfer_data);

use nexus_sdk::contract_api::xcc;

let result = xcc::call(&contract_address, "get_balance", &args);
// Returns: Vec<u8>

let result = xcc::call_value(&contract_address, "deposit", &args, 1000);

let new_contract_id = xcc::deploy(&wasm_code, &init_args, &salt);
// Returns: Vec<u8> (new contract ID)

let new_contract_id = xcc::deploy_template("nep20", &init_args, &salt);

use nexus_sdk::contract_api::bitcoin;

let btc_height = bitcoin::height();
// Returns: i64

let block_hash = bitcoin::hash_at(100);
// Returns: [u8; 32]

let success = bitcoin::request_spend(
    10000,           // amount in sats
    &script_hash,    // destination script hash
    Some(&vault_pk)  // optional vault pubkey
);
// Returns: bool

let valid = bitcoin::verify_inclusion(
    100,        // block height
    &txid,      // transaction ID
    &proof,     // merkle proof
    0           // tx index
);
// Returns: i32 (0 = valid)

use nexus_sdk::contract_api::gas;

let remaining = gas::remaining();
// Returns: u64

use nexus_sdk::contract_api::logger;

logger::log("Debug message");

use nexus_sdk::contract_api::result_bytes;

return result_bytes(&my_data);

use nexus_sdk::contract_api::result_u32;

return result_u32(42);

use nexus_sdk::contract_api::result_u64;

return result_u64(1000000);

use nexus_sdk::contract_api::ez;

let sender = ez::env::sender();      // Same as context::caller()
let addr = ez::env::address();       // Same as context::self_address()
let height = ez::env::height();      // Same as context::block_height()
let time = ez::env::timestamp();     // Same as context::block_timestamp()
let value = ez::env::value();        // Get msg.value (transferred sats)

use nexus_sdk::contract_api::ez::store;

// Integers
store::set_u64(b"counter", 100);
let counter = store::get_u64(b"counter").unwrap_or(0);

store::set_u32(b"version", 1);
let version = store::get_u32(b"version");

// Strings
store::set_string(b"name", "MyToken");
let name = store::get_string(b"name");

// Bytes
store::set_bytes(b"data", &my_bytes);
let data = store::get_bytes(b"data");

// Check existence
if store::exists(b"key") { /* ... */ }

use nexus_sdk::contract_api::ez::ret;

return ret::u64(balance);
return ret::u32(count);
return ret::string("success");
return ret::bytes(&data);

use nexus_sdk::contract_api::ez::abi;

// Parse JSON arguments
let args = abi::parse_args_json(data);
let arg0 = abi::arg_string(ptr, len, 0);
let arg1 = abi::arg_uint64(ptr, len, 1);
let addr = abi::arg_address_hex(ptr, len, 2);

// Hex conversion
let bytes = abi::hex_to_bytes("0x1234");

// Number encoding
let bytes = abi::u64_bytes(1000);
let value = abi::u64_from_bytes(&bytes);

use nexus_sdk::contract_api::ez::standards::nep20;

// Generate storage keys
let balance_key = nep20::balance_key(&address);
let allowance_key = nep20::allowance_key(&owner, &spender);

// Emit standard events
nep20::emit_transfer(&from, &to, amount);
nep20::emit_approval(&owner, &spender, amount);

use nexus_sdk::nexus_nep20_exports;

nexus_nep20_exports!();

// This generates:
// - init_token(name, symbol, decimals, supply)
// - name()
// - symbol()
// - decimals()
// - total_supply() / totalSupply()
// - balance_of(address) / balanceOf(address)
// - transfer(to, amount)
// - approve(spender, amount)
// - allowance(owner, spender)
// - transfer_from(from, to, amount)

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

// State variables
static COUNTER: Mapping<&[u8], U256> = Mapping::new(b"counter");
static OWNER: Mapping<&[u8], Address> = Mapping::new(b"owner");

nexus_fn! {
    fn init() {
        let sender = Blockchain::msg.sender();
        OWNER.set(&b"val".as_slice(), sender);
        COUNTER.set(&b"val".as_slice(), U256::from(0));
        
        emit("Initialized", &[]);
        ret::u32(1)
    }
}

nexus_fn! {
    fn increment() {
        let current = COUNTER.get(&b"val".as_slice());
        let new_value = current.add(U256::from(1));
        COUNTER.set(&b"val".as_slice(), new_value);
        
        emit("Incremented", &[]);
        
        let mut out = [0u8; 32];
        new_value.to_little_endian(&mut out);
        ret::u256(&out)
    }
}

nexus_fn! {
    fn get_count() {
        let current = COUNTER.get(&b"val".as_slice());
        let mut out = [0u8; 32];
        current.to_little_endian(&mut out);
        ret::u256(&out)
    }
}

nexus_fn! {
    fn reset() {
        let caller = Blockchain::msg.sender();
        let owner = OWNER.get(&b"val".as_slice());
        
        require!(caller == owner, "Unauthorized");
        
        COUNTER.set(&b"val".as_slice(), U256::from(0));
        emit("Reset", &[]);
        ret::u32(1)
    }
}

---

## Compilation

```bash
# Build for WASM
cargo build --target wasm32-unknown-unknown --release

# Optimize (optional but recommended)
wasm-opt -O3 target/wasm32-unknown-unknown/release/my_contract.wasm \
  -o my_contract_optimized.wasm