Soroban SDK

https://github.com/stellar/rs-soroban-sdk
Admin
Soroban SDK is a Rust development kit for writing smart contracts on the Stellar Soroban smart...
Tokens:42,190
Snippets:545
Trust Score:9.4
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Rustup

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Installs Rustup, the toolchain installer for Rust. This is the first step in setting up the Rust development environment.

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

--------------------------------

### Deployer::deploy_contract Usage Example

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

Example demonstrating how to invoke the deploy_contract method using the current contract address.

```rust
let current = env.current_contract_address();
let contract_id = env.deployer().deploy_contract(
    current.clone(),
    &preimage_hash,
    &wasm_bytes
);
```

--------------------------------

### Instance::set() usage

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Example of storing a value in instance storage.

```rust
let storage = env.storage().instance();
storage.set(&symbol_short!("admin"), &admin_address);
```

--------------------------------

### Install Rust Stable Toolchain

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Installs the stable Rust toolchain and adds the wasm32v1-none target, which is necessary for building WebAssembly contracts.

```bash
rustup install stable
rustup +stable target add wasm32v1-none
```

--------------------------------

### Open Local Documentation with Make

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Builds and opens the project's documentation locally using the Makefile. Useful for reviewing API docs and project guides.

```bash
make doc
```

--------------------------------

### Implement a complete token contract

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/10-contract-macros.md

A full example demonstrating contract types, error handling, storage management, and unit testing with mocked authentication.

```rust
use soroban_sdk::{
    contract, contractimpl, contracttype, contracterror, 
    Env, Address, Symbol, symbol_short, Vec,
};

#[contracttype]
#[derive(Clone, Debug)]
pub struct Balance {
    pub owner: Address,
    pub amount: u128,
}

#[contracterror]
#[derive(Copy, Clone, Debug)]
#[repr(u32)]
pub enum TokenError {
    InsufficientBalance = 1,
    UnauthorizedTransfer = 2,
    InvalidAmount = 3,
}

#[contract]
pub struct Token;

#[contractimpl]
impl Token {
    pub fn initialize(env: Env, initial_admin: Address) {
        let key = symbol_short!("admin");
        env.storage().instance().set(&key, &initial_admin);
    }
    
    pub fn balance(env: Env, id: Address) -> u128 {
        env.storage().persistent()
            .get(&id)
            .unwrap_or(0)
    }
    
    pub fn transfer(
        env: Env,
        from: Address,
        to: Address,
        amount: u128,
    ) -> Result<(), TokenError> {
        from.require_auth();
        
        if amount == 0 {
            return Err(TokenError::InvalidAmount);
        }
        
        let from_balance: u128 = env.storage().persistent()
            .get(&from)
            .unwrap_or(0);
        
        if from_balance < amount {
            return Err(TokenError::InsufficientBalance);
        }
        
        let to_balance: u128 = env.storage().persistent()
            .get(&to)
            .unwrap_or(0);
        
        env.storage().persistent()
            .set(&from, &(from_balance - amount));
        env.storage().persistent()
            .set(&to, &(to_balance + amount));
        
        env.events().publish(
            (symbol_short!("transfer"), &from, &to),
            amount
        );
        
        Ok(())
    }
}

#[test]
#[cfg(feature = "testutils")]
fn test_transfer() {
    use soroban_sdk::testutils::{Address as _, MockAuth, MockAuthInvoke};
    
    let env = Env::default();
    let admin = Address::generate(&env);
    let alice = Address::generate(&env);
    let bob = Address::generate(&env);
    
    let contract_id = env.register(Token, ());
    let client = TokenClient::new(&env, &contract_id);
    
    // Initialize
    client.initialize(&admin);
    
    // Test transfer with mocked auth
    env.mock_auths(&[MockAuth {
        address: alice.clone(),
        invoke: MockAuthInvoke::Contract((
            contract_id.clone(),
            symbol_short!("transfer"),
            (alice.clone(), bob.clone(), 100u128),
        )),
        sign_args: (),
    }]);
    
    let result = client.transfer(&alice, &bob, &100u128);
    assert!(result.is_ok());
}
```

--------------------------------

### Complete Contract Factory Deployment Example

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

A full implementation of a factory contract that deploys new contracts deterministically and publishes an event.

```rust
#[contract]
pub struct Factory;

#[contractimpl]
impl Factory {
    pub fn create_contract(
        env: Env,
        salt: BytesN<32>,
        wasm: Bytes,
    ) -> Address {
        // Create deterministic contract ID based on salt
        let salt_hash = env.crypto().sha256(&salt);
        
        let current = env.current_contract_address();
        
        // Deploy the contract
        let contract_address = env.deployer().deploy_contract(
            current.clone(),
            &salt_hash,
            &wasm
        );
        
        env.events().publish(
            (symbol_short!("created"),),
            contract_address.clone()
        );
        
        contract_address
    }
}
```

--------------------------------

### Basic Soroban Contract Example

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/README.md

A simple contract implementation with a hello function and a corresponding test case.

```rust
use soroban_sdk::{contract, contractimpl, vec, symbol_short, BytesN, Env, Symbol, Vec};

#[contract]
pub struct Contract;

#[contractimpl]
impl Contract {
    pub fn hello(env: Env, to: Symbol) -> Vec<Symbol> {
        vec![&env, symbol_short!("Hello"), to]
    }
}

#[test]
fn test() {
# }
# #[cfg(feature = "testutils")]
# fn main() {
    let env = Env::default();
    let contract_id = env.register(Contract, ());
    let client = ContractClient::new(&env, &contract_id);

    let words = client.hello(&symbol_short!("Dev"));

    assert_eq!(words, vec![&env, symbol_short!("Hello"), symbol_short!("Dev"),]);
}
# #[cfg(not(feature = "testutils"))]
# fn main() { }
```

--------------------------------

### Common event topic patterns

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

Examples of different topic configurations for event publishing.

```rust
// Event with function name
env.events().publish((symbol_short!("transfer"),), data);

// Event with function and address
env.events().publish((symbol_short!("transfer"), &from_address), data);

// Event with multiple identifiers
env.events().publish(
    (symbol_short!("transfer"), &from, &to),
    amount
);
```

--------------------------------

### Complete event implementation

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

A full example demonstrating how to define a custom event type and emit it within a contract function.

```rust
#[contracttype]
#[derive(Clone)]
pub struct TransferEvent {
    pub from: Address,
    pub to: Address,
    pub amount: u128,
}

#[contract]
pub struct Token;

#[contractimpl]
impl Token {
    pub fn transfer(env: Env, from: Address, to: Address, amount: u128) {
        from.require_auth();
        
        // Update balances...
        
        // Emit transfer event
        env.events().publish(
            (symbol_short!("transfer"), &from, &to),
            TransferEvent { from, to, amount }
        );
    }
}
```

--------------------------------

### Use Logs::print

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/11-additional-modules.md

Examples of printing various types of messages using the logs module.

```rust
env.logs().print("Debug message");
env.logs().print(format!("Value: {}", x));
env.logs().print(100u32);
```

--------------------------------

### Install Rust Nightly Toolchain

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Installs the nightly Rust toolchain and adds the wasm32v1-none target. Nightly is often required for experimental features or specific development tools like MIRI.

```bash
rustup install nightly
rustup +nightly target add wasm32v1-none
```

--------------------------------

### Install Cargo Tools

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Installs the cargo-hack tool, which is used for managing Cargo features and dependencies, ensuring reproducible builds.

```bash
cargo install --locked cargo-hack
```

--------------------------------

### require_auth Usage Example

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Demonstrates verifying authorization for a transfer operation within a contract implementation.

```rust
#[contract]
pub struct PaymentContract;

#[contractimpl]
impl PaymentContract {
    pub fn transfer(env: Env, from: Address, to: Address, amount: u128) {
        from.require_auth();  // Verify 'from' authorized this call
        // Process transfer
    }
}
```

--------------------------------

### Persistent::get() usage

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Example of retrieving a value and handling the Option result.

```rust
let storage = env.storage().persistent();
let balance_key = symbol_short!("balance");
match storage.get::<_, u128>(&balance_key) {
    Some(balance) => env.logs().print(format!("Balance: {}", balance)),
    None => env.logs().print("No balance stored"),
}
```

--------------------------------

### Use GenRange

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/11-additional-modules.md

Examples of generating random values within specific ranges.

```rust
let random_u32 = env.prng().gen_range(0..100u32);
let random_u64 = env.prng().gen_range(1000..2000u64);
```

--------------------------------

### Persistent::set() usage

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Example of storing a value in persistent storage.

```rust
let storage = env.storage().persistent();
let balance_key = symbol_short!("balance");
storage.set(&balance_key, &1000u128);
```

--------------------------------

### require_auth_for_args Usage Example

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Demonstrates verifying authorization for a subset of arguments in a contract method.

```rust
#[contractimpl]
impl PaymentContract {
    pub fn transfer(env: Env, from: Address, to: Address, amount: u128) {
        // Only authorize the transfer amount, not the 'to' address
        from.require_auth_for_args(vec![&env, amount.into_val(&env)]);
        // Process transfer
    }
}
```

--------------------------------

### get()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Returns the element at index i, or None if out of bounds.

```APIDOC
## pub fn get(&self, i: u32) -> Option<T>

### Description
Returns the element at index i, or None if out of bounds.

### Parameters
- **i** (u32) - Required - Index to retrieve

### Returns
- **Option<T>** - The element at the specified index or None.
```

--------------------------------

### Implement TimeLock contract

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

A complete example demonstrating the use of ledger timestamps to enforce a time-based lock on contract actions.

```rust
#[contract]
pub struct TimeLock;

#[contractimpl]
impl TimeLock {
    pub fn lock_until(env: Env, recipient: Address, amount: u128, unlock_time: u64) {
        let now = env.ledger().timestamp();
        assert!(unlock_time > now, "unlock time must be in future");
        
        // Store lock data with unlock time
        let key = symbol_short!("lock");
        env.storage().persistent().set(&key, &(recipient.clone(), amount, unlock_time));
        
        env.events().publish(
            (symbol_short!("locked"),),
            (recipient, amount, unlock_time)
        );
    }
    
    pub fn unlock(env: Env, recipient: Address) {
        let now = env.ledger().timestamp();
        
        let key = symbol_short!("lock");
        if let Some((stored_addr, amount, unlock_time)): Option<(Address, u128, u64)> =
            env.storage().persistent().get(&key)
        {
            assert_eq!(stored_addr, recipient);
            assert!(now >= unlock_time, "cannot unlock yet");
            
            // Transfer amount...
            env.storage().persistent().remove(&key);
        }
    }
}
```

--------------------------------

### Mock Authorization for Testing

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/11-additional-modules.md

Structure and usage example for mocking authorization in contract tests.

```rust
pub struct MockAuth {
    pub address: Address,
    pub invoke: MockAuthInvoke,
    pub sign_args: (),
}
```

```rust
use soroban_sdk::testutils::{MockAuth, MockAuthInvoke};

env.mock_auths(&[MockAuth {
    address: user.clone(),
    invoke: MockAuthInvoke::Contract((
        contract_id.clone(),
        symbol_short!("transfer"),
        (user.clone(), recipient.clone(), 100u128),
    )),
    sign_args: (),
}]);
```

--------------------------------

### Persistent::has() usage

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Example of checking for a key before retrieving it.

```rust
if storage.persistent().has(&balance_key) {
    let balance = storage.persistent().get(&balance_key).unwrap();
}
```

--------------------------------

### get()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Retrieves a value associated with a specific key.

```APIDOC
## get()

### Description
Returns the value for the given key, or None if not found.

### Parameters
- **k** (&Q) - Required - Key to retrieve

### Returns
- **Option<V>**
```

--------------------------------

### Complex Order Book example

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/08-types-contracttype.md

Demonstrates nesting multiple contracttype-annotated structs and enums within a larger data structure.

```rust
#[contracttype]
#[derive(Clone, Debug)]
pub struct Order {
    pub id: u32,
    pub trader: Address,
    pub amount: u128,
    pub price: u128,
    pub status: OrderStatus,
}

#[contracttype]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum OrderStatus {
    Open = 0,
    Filled = 1,
    Cancelled = 2,
}

#[contracttype]
#[derive(Clone, Debug)]
pub struct OrderBook {
    pub buy_orders: Vec<Order>,
    pub sell_orders: Vec<Order>,
    pub last_trade_price: Option<u128>,
}

#[contract]
pub struct Exchange;

#[contractimpl]
impl Exchange {
    pub fn create_order(env: Env, order: Order) -> u32 {
        let mut book: OrderBook = env.storage().persistent()
            .get(&symbol_short!("book"))
            .unwrap_or_else(|| OrderBook {
                buy_orders: Vec::new(&env),
                sell_orders: Vec::new(&env),
                last_trade_price: None,
            });
        
        book.buy_orders.push_back(&order);
        
        env.storage().persistent().set(&symbol_short!("book"), &book);
        env.events().publish((symbol_short!("created"),), order);
        
        order.id
    }
    
    pub fn get_book(env: Env) -> OrderBook {
        env.storage().persistent()
            .get(&symbol_short!("book"))
            .unwrap_or_else(|| OrderBook {
                buy_orders: Vec::new(&env),
                sell_orders: Vec::new(&env),
                last_trade_price: None,
            })
    }
}
```

--------------------------------

### Persistent::extend_ttl() usage

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Example of extending the TTL for a specific key.

```rust
let max_ttl = storage.max_ttl();
storage.persistent().extend_ttl(&key, 0, max_ttl);
```

--------------------------------

### Define complex contract types and errors

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/08-types-contracttype.md

Comprehensive example showing custom structs, enums, and error types used within a contract implementation.

```rust
#[contracttype]
#[derive(Clone, Debug)]
pub struct TokenBalance {
    pub holder: Address,
    pub amount: u128,
    pub last_updated: u64,
}

#[contracttype]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum TransferType {
    Standard = 0,
    Fee = 1,
    Burn = 2,
}

#[contracterror]
#[derive(Copy, Clone, Debug)]
#[repr(u32)]
pub enum TokenError {
    ZeroAmount = 1,
    NoBalance = 2,
    Overflow = 3,
}

#[contract]
pub struct StableToken;

#[contractimpl]
impl StableToken {
    pub fn transfer(
        env: Env,
        from: Address,
        to: Address,
        amount: u128,
        transfer_type: TransferType,
    ) -> Result<(), TokenError> {
        from.require_auth();
        
        if amount == 0 {
            return Err(TokenError::ZeroAmount);
        }
        
        let from_key = symbol_short!("bal_from");
        let from_balance: u128 = env.storage().persistent()
            .get(&from_key)
            .unwrap_or(0);
        
        if from_balance < amount {
            return Err(TokenError::NoBalance);
        }
        
        let to_balance: u128 = env.storage().persistent()
            .get(&symbol_short!("bal_to"))
            .unwrap_or(0);
        
        env.storage().persistent()
            .set(&from_key, &(from_balance - amount));
        env.storage().persistent()
            .set(&symbol_short!("bal_to"), &(to_balance + amount));
        
        let balance = TokenBalance {
            holder: to.clone(),
            amount,
            last_updated: env.ledger().timestamp(),
        };
        
        env.events().publish(
            (symbol_short!("transfer"), &from, &to),
            balance
        );
        
        Ok(())
    }
}
```

--------------------------------

### String Creation Methods

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/05-bytes-string-symbol.md

Methods for initializing a new String instance.

```rust
pub fn new(env: &Env) -> String
```

```rust
pub fn from_str(env: &Env, s: &str) -> String
```

```rust
let message = String::from_str(&env, "Hello, World!");
```

--------------------------------

### Build Project with Make

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Executes the build command defined in the Makefile. Compiles the project's crates and generates artifacts.

```bash
make build
```

--------------------------------

### Implement Contract Storage in Rust

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Demonstrates initializing instance storage and managing persistent storage for token balances with TTL extensions.

```rust
#[contract]
pub struct TokenContract;

#[contractimpl]
impl TokenContract {
    pub fn initialize(env: Env, admin: Address) {
        let storage = env.storage();
        
        // Store admin in instance storage (tied to contract instance)
        storage.instance().set(&symbol_short!("admin"), &admin);
        
        // Store token metadata in instance
        storage.instance().set(&symbol_short!("total_supply"), &0u128);
    }
    
    pub fn transfer(env: Env, from: Address, to: Address, amount: u128) {
        from.require_auth();
        
        let storage = env.storage();
        let persistent = storage.persistent();
        
        // Get and update balances in persistent storage
        let from_balance: u128 = persistent.get(&from).unwrap_or(0);
        assert!(from_balance >= amount);
        
        let to_balance: u128 = persistent.get(&to).unwrap_or(0);
        
        persistent.set(&from, &(from_balance - amount));
        persistent.set(&to, &(to_balance + amount));
        
        // Extend TTL to prevent expiration
        let max_ttl = storage.max_ttl();
        persistent.extend_ttl(&from, 0, max_ttl);
        persistent.extend_ttl(&to, 0, max_ttl);
    }
}
```

--------------------------------

### Get Bytes length

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/05-bytes-string-symbol.md

Returns the number of bytes in the object.

```rust
pub fn len(&self) -> u32
```

--------------------------------

### Perform Complete Integration Testing in Rust

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/11-additional-modules.md

Demonstrates a full test flow including ledger configuration, mock authorization, and contract state verification.

```rust
#[cfg(test)]
mod tests {
    use super::*;
    use soroban_sdk::testutils::{Address as _, Ledger as _, MockAuth, MockAuthInvoke};

    #[test]
    fn test_complete_flow() {
        let env = Env::default();
        
        // Set up ledger
        env.set_sequence(100);
        env.set_timestamp(1234567890);
        
        // Generate test addresses
        let admin = Address::generate(&env);
        let user1 = Address::generate(&env);
        let user2 = Address::generate(&env);
        
        // Register contract
        let contract_id = env.register(MyToken, ());
        let client = MyTokenClient::new(&env, &contract_id);
        
        // Initialize
        client.initialize(&admin);
        
        // Mock authorization for user1
        env.mock_auths(&[MockAuth {
            address: user1.clone(),
            invoke: MockAuthInvoke::Contract((
                contract_id.clone(),
                symbol_short!("transfer"),
                (user1.clone(), user2.clone(), 100u128),
            )),
            sign_args: (),
        }]);
        
        // Perform transfer
        let result = client.transfer(&user1, &user2, &100u128);
        assert!(result.is_ok());
        
        // Verify balance
        let user2_balance = client.balance(&user2);
        assert_eq!(user2_balance, 100);
        
        // Test snapshot
        let snapshot = env.snapshot();
        println!("Ledger entries: {:?}", snapshot.ledger_entries.len());
    }
}
```

--------------------------------

### Get Vec length

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Returns the number of elements in the Vec.

```rust
pub fn len(&self) -> u32
```

```rust
assert_eq!(vec.len(), 3);
```

--------------------------------

### Define Contract Entry Point

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/00-index.md

Use the #[contract] and #[contractimpl] macros to define the contract structure and implementation. Ensure sensitive functions call user.require_auth() to verify authorization.

```rust
#[contract]
pub struct MyContract;

#[contractimpl]
impl MyContract {
    pub fn initialize(env: Env, admin: Address) {
        // Store initialization data
    }
    
    pub fn protected_fn(env: Env, user: Address, data: u32) {
        user.require_auth();  // Verify authorization
        // Process function
    }
}
```

--------------------------------

### Persistent::remove() usage

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Example of removing a key from persistent storage.

```rust
storage.persistent().remove(&balance_key);
```

--------------------------------

### Initialize Contract with ConstructorArgs

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/11-additional-modules.md

Demonstrates using a custom struct as an argument for contract initialization.

```rust
#[contracttype]
#[derive(Clone)]
pub struct InitArgs {
    pub admin: Address,
    pub supply: u128,
}

#[contract]
pub struct Token;

#[contractimpl]
impl Token {
    pub fn init(env: Env, args: InitArgs) {
        env.storage().instance().set(&symbol_short!("admin"), &args.admin);
        env.storage().instance().set(&symbol_short!("supply"), &args.supply);
    }
}
```

--------------------------------

### Get Underlying Val Reference

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Returns a reference to the underlying Val.

```rust
pub fn as_val(&self) -> &Val
```

--------------------------------

### Display project file structure

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/README.md

Visual representation of the documentation directory layout.

```text
output/
├── README.md (this file)
├── 00-index.md (master index)
├── 01-env.md (Env type & core)
├── 02-address.md (Address & auth)
├── 03-storage.md (Storage layers)
├── 04-collections.md (Vec & Map)
├── 05-bytes-string-symbol.md (Data types)
├── 06-crypto.md (Cryptography)
├── 07-events-ledger-deploy.md (Runtime)
├── 08-types-contracttype.md (Types & macros)
├── 09-authentication-auth.md (Authorization)
├── 10-contract-macros.md (Contract definition)
└── 11-additional-modules.md (Utilities)
```

--------------------------------

### Get temporary storage value

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Retrieves a value from temporary storage by key.

```rust
pub fn get<K, V>(&self, key: &K) -> Option<V>
where
    K: IntoVal<Env, Val>,
    V: TryFromVal<Env, Val>,
```

```rust
if let Some(offer) = storage.temporary().get::<_, OfferData>(&offer_key) {
    // Process offer
}
```

--------------------------------

### Create Bytes instances

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/05-bytes-string-symbol.md

Methods for initializing new Bytes objects.

```rust
pub fn new(env: &Env) -> Bytes
pub fn from_slice(env: &Env, slice: &[u8]) -> Bytes
```

```rust
let empty = Bytes::new(&env);
let from_data = Bytes::from_slice(&env, b"hello");
```

--------------------------------

### Run Tests with Make

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Executes all project tests using the Makefile. This is a standard command for verifying code correctness.

```bash
make test
```

--------------------------------

### Get current contract address

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/01-env.md

Retrieves the address of the contract currently being executed.

```rust
pub fn current_contract_address(&self) -> Address
```

```rust
let my_address = env.current_contract_address();
```

--------------------------------

### Instance::get()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Retrieves an instance value.

```APIDOC
## Instance::get()

### Description
Retrieves an instance value.

### Parameters
- **key** (&K) - Required - Key to retrieve

### Returns
- Option<V>
```

--------------------------------

### Format Code with Make

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Runs the code formatting command using the project's Makefile. Ensures code adheres to project style guidelines.

```bash
make fmt
```

--------------------------------

### String::new()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/05-bytes-string-symbol.md

Creates an empty String instance.

```APIDOC
## String::new()

### Description
Creates an empty String.

### Parameters
- **env** (&Env) - Required - The contract environment

### Returns
- **String** - An empty string instance.
```

--------------------------------

### Collection Initialization and Iteration

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/README.md

Create vectors and maps using SDK macros and iterate over collection elements.

```rust
let vec = vec![&env, 1, 2, 3];
let map = map![&env, "key" => value];
for item in vec.iter() { /* process */ }
```

--------------------------------

### Create BytesN instances

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/05-bytes-string-symbol.md

Methods for initializing fixed-length byte arrays.

```rust
pub fn new(env: &Env) -> BytesN<N>
pub fn from_array(env: &Env, arr: &[u8; N]) -> BytesN<N>
pub fn from_slice(env: &Env, slice: &[u8]) -> BytesN<N>
```

```rust
let hash: BytesN<32> = BytesN::from_array(&env, &[0u8; 32]);
let fixed: BytesN<16> = BytesN::from_slice(&env, b"0123456789abcdef");
```

--------------------------------

### Environment and Core API

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/00-index.md

Core environment methods for interacting with the ledger, storage, and contract execution.

```rust
Env
├── storage() → Storage
├── events() → Events
├── ledger() → Ledger
├── crypto() → Crypto
├── prng() → Prng
├── deployer() → Deployer
├── custom_account() → CustomAccount
├── logs() → Logs
├── current_contract_address() → Address
├── invoke_contract<T>() → T
├── try_invoke_contract<T, E>() → Result<>
├── authorize_as_current_contract()
└── panic_with_error()

Val, FromVal, IntoVal, TryFromVal, TryIntoVal
EnvTestConfig
```

--------------------------------

### Define and use a contract error

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/08-types-contracttype.md

Example of defining an enum with #[contracterror] and returning it from a contract function.

```rust
#[contracterror]
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
#[repr(u32)]
pub enum ContractError {
    AlreadyInitialized = 1,
    InsufficientBalance = 2,
    InvalidAmount = 3,
    Unauthorized = 4,
}

#[contract]
pub struct Token;

#[contractimpl]
impl Token {
    pub fn transfer(
        env: Env,
        from: Address,
        to: Address,
        amount: u128,
    ) -> Result<(), ContractError> {
        from.require_auth();
        
        let balance: u128 = env.storage().persistent()
            .get(&from)
            .unwrap_or(0);
        
        if balance < amount {
            return Err(ContractError::InsufficientBalance);
        }
        
        if amount == 0 {
            return Err(ContractError::InvalidAmount);
        }
        
        // Perform transfer...
        Ok(())
    }
}
```

--------------------------------

### map! macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Creates a new Map instance with optional initial key-value pairs.

```APIDOC
## map! macro

### Description
Creates a Map with the given key-value pairs.

### Parameters
- **env** (&Env) - Required - The environment
- **pairs** (K => V) - Optional - Key-value pairs

### Returns
- **Map<K, V>**
```

--------------------------------

### Persistent::get() definition

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Signature for the get method used to retrieve values from persistent storage.

```rust
pub fn get<K, V>(&self, key: &K) -> Option<V>
where
    K: IntoVal<Env, Val>,
    V: TryFromVal<Env, Val>,
```

--------------------------------

### Implement Escrow Contract with Events

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

A complete contract implementation demonstrating persistent storage usage and event publishing for escrow operations.

```rust
#[contracttype]
#[derive(Clone)]
pub struct LockState {
    pub amount: u128,
    pub unlock_time: u64,
}

#[contract]
pub struct EscrowWithEvents;

#[contractimpl]
impl EscrowWithEvents {
    pub fn deposit(env: Env, recipient: Address, amount: u128, duration_secs: u64) {
        let now = env.ledger().timestamp();
        let unlock_time = now + duration_secs;
        
        // Store in persistent storage
        let key = symbol_short!("escrow");
        let state = LockState { amount, unlock_time };
        env.storage().persistent().set(&key, &state);
        
        // Emit event with topics
        env.events().publish(
            (symbol_short!("escrowed"), &recipient),
            EscrowedEvent {
                amount,
                unlock_at: unlock_time
            }
        );
    }
    
    pub fn check_ready(env: Env) -> bool {
        let now = env.ledger().timestamp();
        let key = symbol_short!("escrow");
        
        if let Some(state): Option<LockState> = env.storage().persistent().get(&key) {
            now >= state.unlock_time
        } else {
            false
        }
    }
    
    pub fn release(env: Env, recipient: Address) {
        assert!(Self::check_ready(env), "escrow not yet ready");
        
        let key = symbol_short!("escrow");
        if let Some(state): Option<LockState> = env.storage().persistent().get(&key) {
            env.events().publish(
                (symbol_short!("released"),),
                ReleasedEvent { amount: state.amount }
            );
            
            env.storage().persistent().remove(&key);
        }
    }
}

#[contracttype]
#[derive(Clone)]
pub struct EscrowedEvent {
    pub amount: u128,
    pub unlock_at: u64,
}

#[contracttype]
#[derive(Clone)]
pub struct ReleasedEvent {
    pub amount: u128,
}
```

--------------------------------

### Create I256 Instances

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/08-types-contracttype.md

Methods for initializing I256 values from integers or byte arrays.

```rust
pub fn new(env: &Env, n: i128) -> I256
pub fn zero(env: &Env) -> I256
pub fn from_be_bytes(env: &Env, bytes: &BytesN<32>) -> I256
```

--------------------------------

### Events, Ledger, and Deployment

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/00-index.md

Utilities for emitting events, accessing ledger state, and deploying contracts.

```rust
Events
└── publish<T, E>(topics, data)

Ledger
├── sequence() → u32
├── timestamp() → u64
├── network_id() → BytesN<32>
└── max_live_until_ledger() → u32

Deployer
└── deploy_contract(addr, preimage, wasm) → Address
```

--------------------------------

### Use Imported Contract Client

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/10-contract-macros.md

Demonstrates using an imported contract client within a contract implementation.

```rust
mod token {
    soroban_sdk::contractimport!(file = "token.wasm");
}

#[contract]
pub struct Bridge;

#[contractimpl]
impl Bridge {
    pub fn swap(env: Env, contract_id: Address, amount_in: u128) -> u128 {
        let client = token::ContractClient::new(&env, &contract_id);
        client.swap(&amount_in)
    }
}
```

--------------------------------

### Trait Definition with Default Functions

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/docs/contracttrait.md

Example of a trait definition including functions with and without default implementations, as processed by the `#[contracttrait]` macro.

```Rust
trait Pause {
  // fn without impl
  fn f1(...);
  // fn with default impl
  fn f2(...) {
    ...
  }
}
```

--------------------------------

### Retrieve Environment Reference

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Returns a reference to the associated Env.

```rust
pub fn env(&self) -> &Env
```

--------------------------------

### Print Minimum Supported Rust Version (MSRV) with Make

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/CONTRIBUTING.md

Prints the minimum supported Rust version for the project, as defined in the Makefile. Important for maintaining compatibility.

```bash
make msrv
```

--------------------------------

### Contract Trait Implementation with #[contractimpl]

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/docs/contracttrait.md

Example of implementing a trait within a contract using the `#[contractimpl(contracttrait)]` attribute. This enables the macro to process trait defaults.

```rust
#[contractimpl(contracttrait)]
impl Pause for Contract {
    fn f1() { ... }
}
```

--------------------------------

### Apply multiple macros to contract types and implementations

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/10-contract-macros.md

Demonstrates the usage of contract macros on structs, enums, and implementation blocks. Order of these macros is generally flexible.

```rust
#[contracttype]
#[derive(Clone, Debug)]
pub struct Data {
    pub value: u32,
}

#[contracterror]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum Error {
    Failed = 1,
}

#[contract]
pub struct MyContract;

#[contractimpl]
impl MyContract {
    pub fn process(env: Env, data: Data) -> Result<u32, Error> {
        Ok(data.value)
    }
}
```

--------------------------------

### env()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Returns a reference to the associated Env.

```APIDOC
## pub fn env(&self) -> &Env

### Description
Returns a reference to the associated Env.

### Parameters
- N/A

### Returns
- &Env
```

--------------------------------

### Create Address from strkey string

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Use this method to instantiate an Address from a standard Stellar strkey string. Panics if the provided string is not in the correct G... or C... format.

```rust
let account_address = Address::from_str(&env, "GBNZILSTVQSRDLF4IZ4FGN6SJJ3PS5HOTCFS35MM8FS2RIUYNET5HBZF");
let contract_address = Address::from_str(&env, "CBQHNAXSI55GNQ4UJQ2RLZMK5EVRDWJ3BY4NBWYJYJOQ6GSIG4NZ4OZ7");
```

--------------------------------

### Create U256 Instances

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/08-types-contracttype.md

Methods for initializing U256 values from integers or byte arrays.

```rust
pub fn new(env: &Env, n: u128) -> U256
pub fn zero(env: &Env) -> U256
pub fn from_be_bytes(env: &Env, bytes: &BytesN<32>) -> U256
```

--------------------------------

### Map::new()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Creates an empty Map instance.

```APIDOC
## Map::new()

### Description
Creates an empty Map.

### Parameters
- **env** (&Env) - Required - The contract environment

### Returns
- **Map<K, V>**
```

--------------------------------

### Initialize Empty Map

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Creates an empty Map using the constructor.

```rust
pub fn new(env: &Env) -> Map<K, V>
```

--------------------------------

### Implement Simple Authorization

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/09-authentication-auth.md

Uses require_auth() to verify that the account has authorized the specific contract call.

```rust
#[contract]
pub struct Bank;

#[contractimpl]
impl Bank {
    pub fn withdraw(env: Env, account: Address, amount: u128) -> u128 {
        // Verify account authorized this withdrawal
        account.require_auth();
        
        // Get balance
        let key = &account;
        let balance: u128 = env.storage().persistent()
            .get(key)
            .unwrap_or(0);
        
        assert!(balance >= amount, "insufficient balance");
        
        // Update balance
        env.storage().persistent()
            .set(key, &(balance - amount));
        
        // Emit event
        env.events().publish(
            (symbol_short!("withdraw"),),
            (account.clone(), amount)
        );
        
        amount
    }
}
```

--------------------------------

### Storing Collections in Soroban

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Demonstrates how to initialize and store Vec and Map collections into persistent storage within a contract.

```rust
#[contract]
pub struct DataStore;

#[contractimpl]
impl DataStore {
    pub fn store_list(env: Env, items: Vec<u32>) {
        let mut results = vec![&env];
        
        for item in items.iter() {
            results.push_back(&(item * 2));
        }
        
        let storage = env.storage().persistent();
        storage.set(&symbol_short!("results"), &results);
    }
    
    pub fn store_mapping(env: Env, data: Map<u32, String>) {
        let mut expanded = map![&env];
        
        for (key, value) in data.iter() {
            let new_value = format!("Stored: {}", value);
            expanded.set(&key, &new_value);
        }
        
        let storage = env.storage().persistent();
        storage.set(&symbol_short!("mapping"), &expanded);
    }
}
```

--------------------------------

### Create Vec using vec! macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Instantiate a Vec with or without initial values using the vec! macro.

```rust
let empty = vec![&env];
let with_values = vec![&env, 1, 2, 3];
```

--------------------------------

### Storage::instance()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Returns an Instance storage accessor for contract metadata.

```APIDOC
## Storage::instance()

### Description
Returns an Instance storage accessor for small data bundled with the contract instance.

### Signature
`pub fn instance(&self) -> Instance`

### Returns
- **Instance** - The instance storage accessor.

### Example
```rust
let storage = env.storage();
let admin_key = symbol_short!("admin");
storage.instance().set(&admin_key, &admin_address);
```
```

--------------------------------

### Create and populate Vec

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Initialize an empty Vec and add an element using push_back.

```rust
let mut vec: Vec<u32> = Vec::new(&env);
vec.push_back(&42);
```

--------------------------------

### Instance::set()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Stores a value in instance storage.

```APIDOC
## Instance::set()

### Description
Stores a value in instance storage.

### Parameters
- **key** (&K) - Required - Storage key
- **val** (&V) - Required - Value to store

### Returns
- ()
```

--------------------------------

### Implement Cryptographic Operations in a Soroban Contract

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/06-crypto.md

Demonstrates how to use the env.crypto() interface for Ed25519 verification, SHA-256 hashing, and BLS12-381 aggregate signature verification.

```rust
#[contract]
pub struct SignatureVerification;

#[contractimpl]
impl SignatureVerification {
    pub fn verify_signature(
        env: Env,
        public_key: BytesN<32>,
        message: Bytes,
        signature: BytesN<64>,
    ) -> bool {
        // Verify Ed25519 signature
        env.crypto().ed25519_verify(&public_key, &message, &signature)
    }
    
    pub fn hash_data(env: Env, data: Bytes) -> BytesN<32> {
        // Compute SHA-256
        env.crypto().sha256(&data)
    }
    
    pub fn verify_multiple_bls_signatures(
        env: Env,
        pubkeys: Vec<BytesN<48>>,
        messages: Vec<Bytes>,
        aggregate_sig: BytesN<96>,
    ) -> bool {
        // Verify BLS aggregate signature
        env.crypto().bls12_381_aggregate_verify(&pubkeys, &messages, &aggregate_sig)
    }
}
```

--------------------------------

### Storage::instance() Method

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Returns an Instance storage accessor for contract metadata.

```rust
pub fn instance(&self) -> Instance
```

```rust
let storage = env.storage();
let admin_key = symbol_short!("admin");
storage.instance().set(&admin_key, &admin_address);
```

--------------------------------

### Instance::has()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/03-storage.md

Checks if a key exists in instance storage.

```APIDOC
## Instance::has()

### Description
Checks if a key exists in instance storage.

### Parameters
- **key** (&K) - Required - Key to check

### Returns
- bool
```

--------------------------------

### Import symbol_short! Macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/05-bytes-string-symbol.md

Import the macro required to create short Symbol constants at compile time.

```rust
pub use soroban_sdk_macros::symbol_short;
```

--------------------------------

### Define a Contract Client with #[contractclient]

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/10-contract-macros.md

Use this macro on a trait to generate a client type for calling a contract.

```rust
pub use soroban_sdk_macros::contractclient;

#[contractclient(name = "HelloClient")]
pub trait HelloInterface {
    fn hello(env: &Env, to: Symbol) -> Vec<Symbol>;
}
```

--------------------------------

### Define CreateContractHostFnContext Struct

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/09-authentication-auth.md

Contains information required for contract creation operations.

```rust
pub struct CreateContractHostFnContext {
    pub contract_id_preimage: BytesN<32>,
    pub contract_executable: ContractExecutable,
}
```

--------------------------------

### Authentication Patterns in Rust

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/README.md

Use these methods to verify address authorization and manage sub-contract call permissions.

```rust
address.require_auth();  // Verify address authorized invocation
address.require_auth_for_args(args);  // Verify specific args authorized
env.authorize_as_current_contract(entries);  // Authorize sub-calls
```

--------------------------------

### Vec::new()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Creates an empty Vec instance.

```APIDOC
## Vec::new(env)

### Description
Creates an empty Vec.

### Parameters
- **env** (&Env) - Required - The contract environment.

### Returns
- **Vec<T>** - An empty Vec instance.

### Example
```rust
let mut vec: Vec<u32> = Vec::new(&env);
vec.push_back(&42);
```
```

--------------------------------

### #[contractclient] Macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/10-contract-macros.md

Generates a client type for calling a contract from tests or other contracts.

```APIDOC
## #[contractclient]

### Description
Generates a client type for calling a contract from tests or other contracts.

### Usage
```rust
pub use soroban_sdk_macros::contractclient;

#[contractclient(name = "HelloClient")]
pub trait HelloInterface {
    fn hello(env: &Env, to: Symbol) -> Vec<Symbol>;
}
```
```

--------------------------------

### Create Address from Bytes

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/02-address.md

Instantiates an Address from a Soroban Bytes object containing ASCII strkey bytes. Panics if the bytes do not represent a valid strkey.

```rust
let strkey_bytes = Bytes::from_slice(&env, b"GBNZILSTVQSRDLF4IZ4FGN6SJJ3PS5HOTCFS35MM8FS2RIUYNET5HBZF");
let address = Address::from_string_bytes(&strkey_bytes);
```

--------------------------------

### Create Map with map! Macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Creates a new Map instance using the map! macro.

```rust
macro_rules! map {
    ($env:expr $(,)?) => { ... };
    ($env:expr, $($k:expr => $v:expr),+ $(,)?) => { ... };
}
```

```rust
let empty = map![&env];
let with_values = map![&env, 1 => "a", 2 => "b"];
```

--------------------------------

### Storage API

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/00-index.md

Interfaces for persistent, temporary, and instance-based contract storage.

```rust
Storage
├── persistent() → Persistent
├── temporary() → Temporary
├── instance() → Instance
└── max_ttl() → u32

Persistent / Temporary / Instance
├── get<K, V>(key) → Option<V>
├── set<K, V>(key, value)
├── has<K>(key) → bool
├── remove<K>(key)
└── extend_ttl(key, min, max)
```

--------------------------------

### Deployer::deploy_contract

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/07-events-ledger-deploy.md

Deploys a new contract instance to the network using the provided WASM bytecode and a contract ID preimage for deterministic addressing.

```APIDOC
## Deployer::deploy_contract

### Description
Deploys a contract to a specified address from the given WASM bytes.

### Method
Rust Method

### Signature
`pub fn deploy_contract(self, address: Address, contract_id_preimage: &BytesN<32>, wasm: &Bytes) -> Address`

### Parameters
- **address** (Address) - Required - Address to deploy from (typically current contract)
- **contract_id_preimage** (&BytesN<32>) - Required - Contract ID preimage for deterministic deployment
- **wasm** (&Bytes) - Required - WASM contract bytecode

### Returns
- **Address** - The address of the newly deployed contract

### Example
```rust
let current = env.current_contract_address();
let contract_id = env.deployer().deploy_contract(
    current.clone(),
    &preimage_hash,
    &wasm_bytes
);
```
```

--------------------------------

### #[contractimport] Macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/10-contract-macros.md

Imports a contract from a WASM file and generates client, types, and constants.

```APIDOC
## #[contractimport]

### Description
Imports a contract from a WASM file and generates client, types, and constants.

### Parameters
- **file** (string) - Required - Path to WASM file (relative to workspace root)
- **sha256** (hex string) - Optional - Expected SHA-256 hash for verification

### Usage
```rust
mod contract_a {
    soroban_sdk::contractimport!(file = "contract_a.wasm");
}

mod contract_b {
    soroban_sdk::contractimport!(
        file = "contract_b.wasm",
        sha256 = "d5bc0a5b4c9e72f3a4b6c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e"
    );
}
```
```

--------------------------------

### vec! macro

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/04-collections.md

Creates a new Vec instance containing the provided items.

```APIDOC
## vec!(env, ...items)

### Description
Creates a Vec with the given items.

### Parameters
- **env** (&Env) - Required - The environment.
- **items** (Items) - Optional - The values to populate the Vec with.

### Returns
- **Vec<T>** - The created Vec instance.

### Example
```rust
let empty = vec![&env];
let with_values = vec![&env, 1, 2, 3];
```
```

--------------------------------

### Env::ledger()

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/01-env.md

Returns a Ledger object for accessing current ledger state information.

```APIDOC
## Env::ledger()

### Description
Returns a `Ledger` object for accessing ledger state information.

### Method
`pub fn ledger(&self) -> Ledger`

### Returns
- **Ledger** - An object providing access to ledger state data.

### Example
```rust
let sequence = env.ledger().sequence();
let timestamp = env.ledger().timestamp();
```
```

--------------------------------

### Soroban SDK Module Overview

Source: https://github.com/stellar/rs-soroban-sdk/blob/main/_autodocs/00-index.md

The Soroban SDK is organized into modules that provide access to the ledger environment, contract storage, and cryptographic functions. These modules are designed to be used within smart contracts to interact with the Stellar network.

```APIDOC
## Soroban SDK Modules

### Environment & Core
Provides access to the contract environment, including storage, ledger information, and contract invocation.

### Address & Authorization
Handles Stellar addresses, authorization requirements, and executable types.

### Storage
Manages persistent, temporary, and instance-based contract storage.

### Collections
Provides `Vec<T>` and `Map<K, V>` for data storage within contracts.

### Cryptography
Exposes cryptographic primitives like SHA256, Keccak256, and signature verification (Ed25519, Secp256k1, BLS12-381).

### Contract Macros
- `#[contract]`: Marks a struct as a contract.
- `#[contractimpl]`: Marks an implementation block for exported functions.
- `#[contractclient]`: Generates a client type for contract interaction.
- `#[contractimport]`: Imports a WASM contract.
```
Tokens:
Raw