🛠️ Building Smart Contracts on Stellar SOROBAN

#![no_std]
use olighft_sdk::*;  // Env, Address, Vec, Map, contract, contractimpl, …
                      // plus types, math, crypto, auth, storage, invoke

[dependencies]
olighft-sdk = { path = "../sdk" }

use olighft_sdk::{apply_bps, fee_bps, isqrt, daily_reward, convert_rate};

// 0.3 % swap fee on 10 000 tokens
let fee = fee_bps(10_000, 30);        // → Some(30)

// Boost multiplier: 1.5× (15 000 bps)
let boosted = apply_bps(amount, 15_000); // → Some(amount * 1.5)

// AMM liquidity: integer sqrt for LP shares
let shares = isqrt(reserve_a * reserve_b);

// Daily reward from annual APY (10 % = 1 000 bps)
let reward = daily_reward(1_000_000, 1_000); // → Some(273)

// Cross-asset via oracle rate (1e7 scale)
let usd_out = convert_rate(xlm_amount, rate); // → amount * rate / 1e7

use olighft_sdk::{sha256, keccak256, verify_ed25519, hash_bytes};

// SHA-256 of raw bytes
let digest: BytesN<32> = sha256(&env, &data);

// Keccak-256 (Ethereum-compatible)
let k_digest = keccak256(&env, &data);

// Ed25519 signature verification (traps on failure)
verify_ed25519(&env, &public_key, &message, &signature);

// Derive a namespaced hash from a byte slice
let nonce_hash = hash_bytes(&env, b"nonce:alice:42");

use olighft_sdk::{
    instance_get, instance_set, instance_get_or,
    persistent_get, persistent_set, persistent_has,
    temporary_set, temporary_get,
};

// Instance tier — admin config
instance_set(&env, &DataKey::Admin, &admin);
let admin: Address = instance_get(&env, &DataKey::Admin).unwrap();

// Persistent tier — user balances
persistent_set(&env, &DataKey::Balance(user.clone()), &amount);
let bal: i128 = persistent_get(&env, &key).unwrap_or(0);

// Or use get-with-default:
let total: i128 = instance_get_or(&env, &DataKey::TotalSupply, 0);

// Temporary tier — nonces, caches
temporary_set(&env, &nonce_key, &1u32);

use olighft_sdk::{
    transfer, token_client, invoke, invoke_void,
    ContractId, register_contract, resolve_contract,
};

// Register sibling contracts at initialisation
register_contract(&env, &ContractId::Token, &token_addr);
register_contract(&env, &ContractId::Staking, &staking_addr);

// Later: resolve and call
let token = resolve_contract(&env, &ContractId::Token).unwrap();
transfer(&env, &token, &from, &to, &amount);

// Or build a full token client
let client = token_client(&env, &token);
client.balance(&user);

// Generic invocation of any contract function
let rewards: i128 = invoke(
    &env,
    &staking_addr,
    &Symbol::new(&env, "pending_rewards"),
    (Vec::new(&env),), // args
);

# See all commands
olighft --help

# Check workspace health + tool availability
olighft config

# Build all contracts with full optimisation
olighft build --optimize

# Build only the token contract
olighft build -c token

# Build with debug logs enabled
olighft build -p release-with-logs

# Build + Soroban-specific optimisation pass
olighft build --optimize --soroban-optimize

# Test all contracts
olighft test

# Test only staking, with output visible
olighft test -c staking -- --nocapture

# Run only tests matching "compound"
olighft test -f compound

# With debug assertions for detailed errors
olighft test --with-logs

# Human-readable output
olighft inspect -c token

# Output:
#   file    : target/.../olighft_token.wasm
#   size    : 42.3 KiB
#   sha256  : a1b2c3d4e5f6...
#   exports (8):
#     [fn] initialize
#     [fn] transfer
#     [fn] approve
#     ...

# Machine-readable JSON (for CI pipelines)
olighft inspect -c token --json

# Full ABI via soroban/stellar CLI
olighft inspect -c token --abi

# Show all contract versions
olighft version show
#   token              1.0.0
#   staking            1.0.0
#   card_staking       1.0.0
#   ...

# Bump token to 1.1.0 with changelog
olighft version bump -c token -l minor -m "added burn_from function"

# Set an explicit version
olighft version set -c payment -v 2.0.0

# View changelogs
olighft version log -c token

# Deploy all contracts to testnet (builds first)
olighft deploy -n testnet -s alice

# Deploy only payment contract, skip build
olighft deploy -c payment -n testnet -s alice --no-build

# Dry-run — print commands without executing
olighft deploy -n mainnet -s deployer --dry-run

# Outputs a deploy-testnet.json manifest:
# { "network": "testnet", "contracts": [
#     { "contract": "token",   "id": "CABC..." },
#     { "contract": "staking", "id": "CDEF..." },
#     ... ] }

# Start sandbox, deploy all contracts, open REPL
olighft sandbox --auto-deploy --repl

# Output:
#   mode     : local (identical to on-chain)
#   rpc      : http://localhost:8000
#   accounts : 3
#
#   Deployed Contracts:
#     token            CABC...
#     staking          CDEF...
#     card_staking     CGHI...
#     ...

# Interactive REPL commands:
olighft> invoke token transfer --from test-account-0 --to test-account-1 --amount 1000
olighft> invoke staking pending_rewards --user test-account-0
olighft> accounts
olighft> contracts
olighft> ledger
olighft> quit

# Install bytecode once
stellar contract install --wasm token.wasm --network testnet --source deployer
# Output: WASM_HASH abc123...

# Deploy multiple instances from the same bytecode
stellar contract deploy --wasm-hash abc123... --network testnet --source deployer  # → Gold
stellar contract deploy --wasm-hash abc123... --network testnet --source deployer  # → Visa
stellar contract deploy --wasm-hash abc123... --network testnet --source deployer  # → Platinum

// Instance — lives as long as the contract
env.storage().instance().set(&"admin", &admin);

// Persistent — long-lived, needs TTL extension
env.storage().persistent().set(&user_key, &balance);
env.storage().persistent().extend_ttl(&user_key, 100, 100);

// Temporary — auto-expires, cheapest for ephemeral data
env.storage().temporary().set(&nonce_key, &nonce);

#[cfg(test)]
mod tests {
    use super::*;
    use soroban_sdk::{testutils::Address as _, Env};

    #[test]
    fn test_stake_and_compound() {
        let env = Env::default();
        env.mock_all_auths();

        let contract_id = env.register_contract(None, SmartCardCoin);
        let client = SmartCardCoinClient::new(&env, &contract_id);

        let admin = Address::generate(&env);
        let user  = Address::generate(&env);
        let token = env.register_stellar_asset_contract(admin.clone());

        // Initialize
        client.initialize(&admin, &token, &850); // 8.5% base APY

        // Stake 1000 tokens for 90 days with auto-compound
        let pos = client.stake(&user, &1000_0000000, &90, &true);

        assert_eq!(pos.amount, 1000_0000000);
        assert_eq!(pos.apy_bps, 850 + 350); // base + 90-day lock boost
        assert!(pos.auto_compound);

        // Advance ledger time by 30 days
        env.ledger().set(soroban_sdk::testutils::Ledger {
            timestamp: env.ledger().timestamp() + 30 * 86400,
            ..Default::default()
        });

        // Compound rewards
        let reward = client.compound(&user);
        assert!(reward > 0, "Should have accrued rewards");
    }
}

# Install WASM on mainnet
soroban contract install \
  --wasm target/wasm32-unknown-unknown/release/future_crypto_card.wasm \
  --network mainnet \
  --source deployer-key

# Output: WASM hash (e.g., abc123...)

# Deploy contract instance from installed WASM
soroban contract deploy \
  --wasm-hash abc123... \
  --network mainnet \
  --source deployer-key

# Output: Contract ID (e.g., CDLZ...X7KQ)

# Call initialize with admin, token address, and base APY
soroban contract invoke \
  --id CDLZ...X7KQ \
  --network mainnet \
  --source admin-key \
  -- initialize \
  --admin GDQP...ADMIN \
  --token_addr CCUS...USDC \
  --base_apy_bps 850

# Stake 500 XLM for 90 days with auto-compound
soroban contract invoke \
  --id CDLZ...X7KQ \
  --network mainnet \
  --source user-key \
  -- stake \
  --user GBUY...USER \
  --amount 5000000000 \
  --lock_days 90 \
  --auto_compound true

# Compound rewards
soroban contract invoke \
  --id CDLZ...X7KQ \
  --network mainnet \
  --source user-key \
  -- compound \
  --user GBUY...USER

# Read balance (no auth needed)
soroban contract invoke \
  --id CDLZ...X7KQ \
  --network mainnet \
  -- get_balance \
  --user GBUY...USER

import { Contract, Server, TransactionBuilder } from '@stellar/stellar-sdk';

const server = new Server('https://soroban-rpc.mainnet.stellar.gateway.fm');
const contract = new Contract('CDLZ...X7KQ');

// Build a stake transaction
async function stakeTokens(userKey, amount, lockDays) {
  const account = await server.getAccount(userKey.publicKey());

  const tx = new TransactionBuilder(account, {
    fee: '100',
    networkPassphrase: 'Public Global Stellar Network ; September 2015',
  })
  .addOperation(
    contract.call(
      'stake',
      userKey.publicKey(),  // user
      amount,               // i128
      lockDays,             // u64
      true,                 // auto_compound
    )
  )
  .setTimeout(30)
  .build();

  // Simulate → sign → submit
  const simulated = await server.simulateTransaction(tx);
  const prepared  = assembleTransaction(tx, simulated);
  prepared.sign(userKey);
  const result = await server.sendTransaction(prepared);
  return result;
}

# Add the WebAssembly compilation target (required for contract builds)
rustup target add wasm32-unknown-unknown

# Keep your toolchain up to date
rustup update

# Install the latest Stellar CLI
cargo install --locked stellar-cli

# Verify the installation
stellar --version
# → stellar-cli 21.X.X

# The older `soroban` command still works as an alias
# but `stellar` is the canonical name going forward

# From the contracts/ workspace root:
cargo install --path cli

# Or build without installing globally:
cargo build -p olighft-cli --release
# Binary at: target/release/olighft(.exe)

# Verify
olighft --version
olighft config    # shows workspace health + toolchain status

# Add Stellar Testnet
stellar network add testnet \
  --rpc-url https://soroban-testnet.stellar.org \
  --network-passphrase "Test SDF Network ; September 2015"

# Add Stellar Mainnet
stellar network add mainnet \
  --rpc-url https://soroban-rpc.mainnet.stellar.gateway.fm \
  --network-passphrase "Public Global Stellar Network ; September 2015"

# List configured networks
stellar network ls
# → testnet    https://soroban-testnet.stellar.org
# → mainnet    https://soroban-rpc.mainnet.stellar.gateway.fm

# Generate a new identity (stores keypair locally)
stellar keys generate alice --network testnet

# View the public address
stellar keys address alice
# → GBXYZ...ABC

# Fund from Friendbot (10,000 free testnet XLM)
stellar keys fund alice --network testnet

# Verify the balance
stellar account show --network testnet --source alice

# Create additional test accounts if needed
stellar keys generate bob --network testnet
stellar keys fund bob --network testnet

{
  // Point rust-analyzer to the WASM target for accurate diagnostics
  "rust-analyzer.cargo.target": "wasm32-unknown-unknown",

  // Enable all features for SDK test utilities
  "rust-analyzer.cargo.features": "all",

  // Check on save (fast feedback loop)
  "rust-analyzer.check.command": "clippy",

  // Inline type hints (helpful for Soroban env types)
  "rust-analyzer.inlayHints.typeHints.enable": true,

  // Exclude build artifacts from file watcher
  "files.watcherExclude": {
    "**/target/**": true
  }
}

# Scaffold a new Soroban project
stellar contract init my-first-contract
cd my-first-contract

# Build to WASM
cargo build --target wasm32-unknown-unknown --release
# → target/wasm32-unknown-unknown/release/my_first_contract.wasm

# Run tests
cargo test

# Or use the OLIGHFT CLI (from the OLIGHFT workspace):
olighft build
olighft test

# Rust compiler
rustc --version                           # → rustc 1.7X.0

# Cargo build tool
cargo --version                           # → cargo 1.7X.0

# WASM target installed
rustup target list --installed | grep wasm # → wasm32-unknown-unknown

# Stellar CLI
stellar --version                         # → stellar-cli 21.X.X

# Networks configured
stellar network ls                        # → testnet, mainnet

# Identity exists and is funded
stellar keys address alice                # → GBXYZ...

# Build works end-to-end
cargo build --target wasm32-unknown-unknown --release

# (Optional) OLIGHFT CLI
olighft config                            # → shows workspace + toolchain

use soroban_sdk::{testutils::Address as _, Address, Env};

#[test]
fn test_stake_rejects_zero_amount() {
    let env = Env::default();
    env.mock_all_auths();

    let contract_id = env.register_contract(None, StakingContract);
    let client = StakingContractClient::new(&env, &contract_id);
    let user = Address::generate(&env);

    // Zero stake should panic
    let result = client.try_stake(&user, &0);
    assert!(result.is_err(), "should reject zero amount");
}

#[test]
fn test_withdraw_requires_auth() {
    let env = Env::default();
    // Do NOT mock auths — test real auth enforcement

    let contract_id = env.register_contract(None, StakingContract);
    let client = StakingContractClient::new(&env, &contract_id);
    let attacker = Address::generate(&env);
    let victim = Address::generate(&env);

    // Attacker trying to withdraw victim's funds should fail
    let result = client.try_withdraw(&victim, &1000);
    assert!(result.is_err(), "should fail without auth");
}

#[test]
fn test_overflow_does_not_wrap() {
    let env = Env::default();
    env.mock_all_auths();

    let contract_id = env.register_contract(None, StakingContract);
    let client = StakingContractClient::new(&env, &contract_id);
    let user = Address::generate(&env);

    // Staking i128::MAX should not silently overflow
    let result = client.try_stake(&user, &i128::MAX);
    assert!(result.is_err(), "should reject overflow-prone amount");
}