Sanctifier Finding Codes Reference: S001–S017 and Beyond

#[contractimpl]
impl MyContract {
    // S001: writes to storage, never calls require_auth
    pub fn set_data(env: Env, val: u32) {
        env.storage().instance().set(&DataKey::Val, &val);
    }
}

#[contractimpl]
impl MyContract {
    pub fn set_data(env: Env, val: u32) {
        env.require_auth();                               // ← auth guard
        env.storage().instance().set(&DataKey::Val, &val);
    }
}

pub fn unsafe_fn(env: Env) {
    panic!("Something went wrong");       // S002
}

pub fn unsafe_unwrap(env: Env) {
    let x: Option<u32> = None;
    let y = x.unwrap();                   // S002
}

pub fn unsafe_expect(env: Env) {
    let x: Option<u32> = None;
    let y = x.expect("Failed to get x"); // S002
}

pub fn safe_balance(env: Env, id: Address) -> Result<i128, Error> {
    env.storage()
        .persistent()
        .get(&DataKey::Balance(id))
        .ok_or(Error::NotFound)           // typed error instead of panic
}

pub fn add_balances(env: Env, a: u64, b: u64) -> u64 {
    a + b              // S003: unchecked addition
}

pub fn accumulate(env: Env, mut balance: u64, amount: u64) -> u64 {
    balance += amount; // S003: unchecked compound assignment
    balance
}

pub fn add_safe(env: Env, a: u64, b: u64) -> Result<u64, Error> {
    a.checked_add(b).ok_or(Error::Overflow)
}

pub fn accumulate_safe(env: Env, balance: u64, amount: u64) -> Result<u64, Error> {
    balance.checked_add(amount).ok_or(Error::Overflow)
}

#[contracttype]
pub struct HugeState {
    pub buffer_a: Bytes,  // 64 bytes
    pub buffer_b: Bytes,  // 64 bytes
    pub data: Vec<u128>,  // 8 + 16 = 24 bytes (undercount for large vecs)
    // estimated total approaches 64 KB warning threshold at scale
}

#[contractimpl]
impl MyContract {
    pub fn write_a(env: Env) {
        // S005: "USER" used twice in persistent storage
        env.storage().persistent().set(&"USER", &1u32);
    }

    pub fn write_b(env: Env) {
        // S005: same key, same tier — collision
        env.storage().persistent().set(&"USER", &2u32);
    }
}

#[contracttype]
pub enum DataKey {
    UserA,
    UserB,
}

env.storage().persistent().set(&DataKey::UserA, &1u32);
env.storage().persistent().set(&DataKey::UserB, &2u32);

[[custom_rules]]
name = "no_unsafe_block"
pattern = "unsafe \\{"
severity = "error"

[[custom_rules]]
name = "todo_comment"
pattern = "TODO"
severity = "info"

pub fn my_fn() {
    // TODO: implement this             // S007: todo_comment
    unsafe {                           // S007: no_unsafe_block
        let x = 1;
    }
}

// S008: "transfer" published with 2 topics here ...
env.events().publish(("transfer", from), amount);

// ... and with 3 topics elsewhere in the same file
env.events().publish(("transfer", from, to), amount);

// Consistent schema — always 3 topics for "transfer"
env.events().publish(
    (symbol_short!("transfer"), from, to),
    amount,
);

fn internal_fn() -> Result<u32, Error> { Ok(42) }

#[contractimpl]
impl MyContract {
    pub fn public_fn(env: Env) -> u32 {
        internal_fn(); // S009: Result is discarded
        0
    }
}

pub fn public_fn(env: Env) -> Result<u32, Error> {
    let val = internal_fn()?;   // propagate with ?
    Ok(val)
}

pub fn upgrade(env: Env, wasm_hash: BytesN<32>) {
    // S010: no require_auth, no timelock — anyone can upgrade
    env.deployer().update_current_contract_wasm(wasm_hash);
}

pub fn upgrade(env: Env, admin: Address, wasm_hash: BytesN<32>) {
    admin.require_auth();
    env.deployer().update_current_contract_wasm(wasm_hash);
}

S011  balance_non_negative  VIOLATED
      Counterexample: from_balance=0, amount=1, result_balance=-1
      Call: transfer(from_balance=0, amount=1) -> result_balance = -1

// S012: admin address baked into source
const ADMIN: &str = "GABC...XYZ";

pub fn admin_action(env: Env) {
    let caller = env.invoker();
    assert_eq!(caller.to_string(), ADMIN);
}

pub fn admin_action(env: Env) {
    let admin: Address = env.storage()
        .instance()
        .get(&DataKey::Admin)
        .expect("not initialized");
    admin.require_auth();
}

pub fn transfer(env: Env, from: Address, to: Address, amount: i128) {
    // S013: no amount > 0 guard, no from != to check
    from.require_auth();
    // ... balance update
}

pub fn transfer(env: Env, from: Address, to: Address, amount: i128) {
    assert!(amount > 0, "amount must be positive");
    assert!(from != to, "self-transfer not allowed");
    from.require_auth();
    // ... balance update
}

pub fn always_passes(env: Env, amount: i128) {
    assert!(true, "this assertion does nothing");   // S015: dead guard
}

#[contracterror]
pub enum Error {
    NotFound    = 1,
    Unauthorized = 1,  // S016: duplicate discriminant
}

#[contracterror]
pub enum Error {
    NotFound     = 1,
    Unauthorized = 2,  // unique discriminants
}

pub fn calculate_fee(amount: i128, fee_bps: i128) -> i128 {
    // S017: rounds to zero when amount < 10_000 / fee_bps
    amount * fee_bps / 10_000
}

pub fn calculate_fee(amount: i128, fee_bps: i128) -> i128 {
    // Ceiling division prevents rounding to zero
    (amount * fee_bps + 9_999) / 10_000
}

#[contractimpl]
impl Token {
    pub fn balance(env: Env, id: Address) -> i128 {
        // SANCT_UNWRAP: unwrap_or_default silently returns 0 for accounts
        // that never held tokens — callers may misinterpret this as a real zero balance
        env.storage()
            .persistent()
            .get(&DataKey::Balance(id))
            .unwrap_or_default()
    }
}

pub fn balance(env: Env, id: Address) -> i128 {
    env.storage()
        .persistent()
        .get(&DataKey::Balance(id))
        .unwrap_or(0)   // explicit zero default: uninitialised account has zero balance
}

pub fn batch_transfer(env: Env, recipients: Vec<Address>, amounts: Vec<i128>) {
    // SANCT_ARG_DOS: no length check — caller controls loop iterations
    for (recipient, amount) in recipients.iter().zip(amounts.iter()) {
        // ... transfer logic
    }
}

const MAX_BATCH: u32 = 50;

pub fn batch_transfer(env: Env, recipients: Vec<Address>, amounts: Vec<i128>) {
    assert!(recipients.len() <= MAX_BATCH, "batch too large");
    for (recipient, amount) in recipients.iter().zip(amounts.iter()) {
        // ... transfer logic
    }
}