Deploy a Contract

git clone https://github.com/yattacorp/nexus-contract-template
cd nexus-contract-template

#![no_std]
extern crate alloc;

use nexus_sdk::contract_api::{ez::prelude::*, ez::ret};

// State variables — persistent between calls
static INITIALIZED: Mapping<&[u8], bool> = Mapping::new(b"init");
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);
        INITIALIZED.set(&b"val".as_slice(), true);
        ret::u32(1)
    }
}

nexus_fn! {
    fn greet() {
        ret::string("Hello, NEXUS!")
    }
}

cargo build --target wasm32-unknown-unknown --release
# Output: target/wasm32-unknown-unknown/release/my_nexus_contract.wasm

// contract-tests/src/lib.rs
use nexus_sdk::testing::{TestEnv, accounts};

const WASM: &[u8] = include_bytes!(
    "../../target/wasm32-unknown-unknown/release/my_nexus_contract.wasm"
);

#[test]
fn test_greet() {
    let mut env = TestEnv::new();
    let contract = env.deploy(WASM).expect("deploy failed");

    env.set_caller(accounts::ALICE);
    let result = env.call(&contract, "greet", &[]).unwrap();
    result.assert_success();
}

# Build WASM first, then run tests
cargo build --target wasm32-unknown-unknown --release && cargo test

import { NexusClient, Wallet } from '@yattacorp/nexus-sdk';
import { readFileSync } from 'fs';

// Wallet must be mnemonic-based — required for vault creation and renewal key derivation
const wallet = Wallet.fromMnemonic(
  process.env.MNEMONIC!,
  'mainnet',    // 'mainnet' | 'regtest'
  undefined,    // use default BIP-32 path
  'zcash'
);

const client = new NexusClient(
  { rpcUrl: 'https://api.yattacorp.xyz', network: 'mainnet', chain: 'zcash' },
  wallet
);

const wasm = readFileSync(
  './target/wasm32-unknown-unknown/release/my_nexus_contract.wasm'
);

// Returns: { contractId, txHash, gasUsed, blockHeight }
const { contractId } = await client.deployContract(wasm);
console.log('Deployed at:', contractId);

// State-changing call — mines on-chain, returns { success, txHash, result, gasUsed }
const result = await client.callContract(contractId, 'greet', []);
console.log('Result:', result.result);

// Stealth call — same execution, caller identity hidden on-chain
const result = await client.stealthCallContract(contractId, 'greet', []);

// Read-only query — no gas, no transaction
const value = await client.queryContract(contractId, 'greet', []);