How to choose the right storage type for your use case

use soroban_sdk::{contract, contractimpl, contracttype, Address, Env};

#[contracttype]
pub enum DataKey {
    Points(Address),
}

#[contract]
pub struct LoyaltyPointsContract;

#[contractimpl]
impl LoyaltyPointsContract {
    // This function redeems points according to the user's balance
    pub fn redeem_points(env: Env, user: Address, points: u64) -> bool {
        user.require_auth();
        let key = DataKey::Points(user.clone());
        let current_points: u64 = env.storage().persistent().get(&key).unwrap_or(0);

        if current_points >= points {
            let new_points = current_points - points;
            env.storage().persistent().set(&key, &new_points);
            true
        } else {
            false
        }
    }

    // This function retrieves the user's points balance
    pub fn get_points(env: Env, user: Address) -> u64 {
        let key = DataKey::Points(user);
        env.storage().persistent().get(&key).unwrap_or(0)
    }

    // ...
    // This example omits functions that add points to the users, see the next
    // section for these.
}

use soroban_sdk::{contractimpl, contracttype, Address, Env};

// This is the `DataKey` from the previous section, with `Admin` added. Declare
// it only once in your contract.
#[contracttype]
pub enum DataKey {
    Points(Address),
    Admin,
}

#[contractimpl]
impl LoyaltyPointsContract {
    // Initialize a contract with the administrator address.
    pub fn __constructor(env: Env, admin: Address) {
        env.storage().instance().set(&DataKey::Admin, &admin);
    }

    pub fn add_points(env: Env, user: Address, points: u64) {
        // Load the admin from the instance storage and make sure it has
        // authorized this invocation.
        let admin: Address =
             env.storage().instance().get(&DataKey::Admin).unwrap();
        admin.require_auth();

        let key = DataKey::Points(user.clone());
        let current_points: u64 = env.storage().persistent().get(&key).unwrap_or(0);

        let new_points = current_points + points;
        env.storage().persistent().set(&key, &new_points);
    }
}

use soroban_sdk::{contract, contractimpl, contracttype, Address, Env};

#[contracttype]
pub enum DataKey {
    Bid(Address),
}

#[contracttype]
pub struct Bid {
    value: i128,
    // The bid is no longer valid after this ledger sequence number. It's
    // important to store this value alongside the entry, as the entry may live
    // longer than expected.
    expiration_ledger_seq: u32,
}

#[contract]
pub struct AuctionContract;

#[contractimpl]
impl AuctionContract {
    // This function lets a user place a bid that lives only until the auction ends.
@@ -185,29 +190,28 @@ impl AuctionContract {
        });
        // Compute the TTL that the bid requires.
        let bid_ttl = bid_expiration_ledger_seq
            .checked_sub(env.ledger().sequence())
            .unwrap();
        // Extend the TTL for the bid, such that it's guaranteed to live at
        // least until the `bid_expiration_ledger_seq` that the user has
        // requested. This operation will fail if the extension is longer than
        // the protocol allows, so there is no need to further validate
        // `bid_ttl`.
        env.storage().temporary().extend_ttl(&bid_key, bid_ttl, bid_ttl);
    }

    // This function returns a user's bid (0 if it has expired).
    pub fn get_bid(env: Env, user: Address) -> i128 {
        let maybe_bid: Option<Bid> = env.storage().temporary().get(&DataKey::Bid(user));
        if let Some(bid) = maybe_bid {
            if bid.expiration_ledger_seq >= env.ledger().sequence() {
                bid.value
            } else {
                // Even though the entry is still in the storage, it has
                // logically expired. Somebody must have extended the entry in
                // order to trick our contract, so return 0.
                0
            }

        } else {
            // There is no bid for the user - it either hasn't existed at all,
            // or has been removed from the temporary storage. In either case,
            // just return 0.
            0
        }
    }

    // ...
    // The functions that initialize and run the auctions are omitted.
}