Stellar Technical Overview

struct MessagingParams {
    dst_eid: u32,          // Destination endpoint ID
    receiver: BytesN<32>,  // Recipient address (32-byte canonical form)
    message: Bytes,        // Application-level message payload
    options: Bytes,        // Execution options (gas, value, etc.)
    pay_in_zro: bool,      // Pay fees in ZRO token instead of native
}

struct Origin {
    src_eid: u32,          // Source endpoint ID
    sender: BytesN<32>,    // Sender address (32-byte canonical form)
    nonce: u64,            // Message sequence number
}

struct MessagingFee {
    native_fee: i128,      // Fee in native token (XLM)
    zro_fee: i128,         // Fee in ZRO token (if pay_in_zro = true)
}

struct MessagingReceipt {
    guid: BytesN<32>,      // Globally unique message identifier
    nonce: u64,            // Outbound nonce for this path
    fee: MessagingFee,     // Actual fees charged
}

// Quote the messaging fee
let fee = oft.quote_send(&from, &send_param, &false);

// Execute the send
let (receipt, oft_receipt) = oft.send(&from, &send_param, &fee, &refund_address);

// DVN submits verification (on destination chain)
uln302.verify(&dvn, &packet_header, &payload_hash, &confirmations);

let is_ready = uln302.verifiable(&packet_header, &payload_hash);

uln302.commit_verification(&packet_header, &payload_hash);

oapp.lz_receive(
    &executor,       // Executor address (must authorize)
    &origin,         // Source chain info
    &guid,           // Message GUID
    &message,        // Application payload
    &extra_data,     // Additional data
    &value,          // Native token value to forward
);

endpoint.skip(&caller, &receiver, &src_eid, &sender, &nonce);

endpoint.clear(&caller, &origin, &receiver, &guid, &message);

// Use Some(payload_hash) for an existing verified hash.
// For a future nonce with no stored hash, set expected_payload_hash to None instead.
let expected_payload_hash = Some(payload_hash);
endpoint.nilify(&caller, &receiver, &src_eid, &sender, &nonce, &expected_payload_hash);

endpoint.burn(&caller, &receiver, &src_eid, &sender, &nonce, &payload_hash);

#[oapp]
pub struct MyOFT;

// The #[oapp] macro generates:
// - OAppCore (endpoint, peer, set_peer, set_delegate)
// - OAppSenderInternal (__quote, __lz_send)
// - OAppReceiver (lz_receive, allow_initialize_path, next_nonce)
// - OAppOptionsType3 (enforced_options, set_enforced_options, combine_options)

#[storage]
enum OFTStorage {
    #[instance(u32)]
    DecimalsDiff,        // Immutable after construction
    #[instance(Address)]
    Token,               // Immutable after construction
    #[instance(Address)]
    MsgInspector,        // Optional, mutable
}

# Set TTL extension parameters (owner/admin only)
# Values are in ledgers (~5 seconds each)
stellar contract invoke \
  --id <CONTRACT_ADDRESS> \
  --network testnet \
  --source my-account \
  -- \
  set_ttl_configs \
  --instance '{"threshold": 1000, "extend_to": 5000}' \
  --persistent '{"threshold": 1000, "extend_to": 5000}'

stellar contract read \
  --id <CONTRACT_ADDRESS> \
  --network testnet \
  --key <STORAGE_KEY> \
  --durability persistent

// Upgrade to a new WASM implementation
contract.upgrade(&new_wasm_hash);

// Must call migrate after upgrade to clear the migration flag
contract.migrate(&migration_data);

# Step 1: Begin transfer (2-step)
# TTL is in ledgers (~5s each). 120960 ledgers ≈ 1 week.
stellar contract invoke \
  --id <CONTRACT_ADDRESS> \
  --network testnet \
  --source current-owner \
  -- \
  begin_ownership_transfer \
  --new_owner <NEW_OWNER_ADDRESS> \
  --ttl 120960

# Step 2: Accept transfer (from new owner)
stellar contract invoke \
  --id <CONTRACT_ADDRESS> \
  --network testnet \
  --source new-owner \
  -- \
  accept_ownership

stellar contract invoke \
  --id <YOUR_OAPP_ADDRESS> \
  --network testnet \
  --source my-account \
  -- \
  set_delegate \
  --delegate <OPS_ADDRESS> \
  --operator <OWNER_ADDRESS>

#[only_role(operator, "MINTER_ROLE")]
fn mint(env: &Env, to: &Address, amount: i128, operator: &Address) {
    // Only accounts with MINTER_ROLE can call this
}