@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/oapps/oft/src/types.rs

@@ -0,0 +1,38 @@
+use soroban_sdk::{contracttype, Bytes, BytesN};
+
+/// Parameters for sending OFT tokens cross-chain
+#[contracttype]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct SendParam {
+    pub dst_eid: u32,
+    pub to: BytesN<32>,
+    pub amount_ld: i128,
+    pub min_amount_ld: i128,
+    pub extra_options: Bytes,
+    pub compose_msg: Bytes,
+    pub oft_cmd: Bytes,
+}
+
+/// Transfer limits for OFT operations
+#[contracttype]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct OFTLimit {
+    pub min_amount_ld: i128,
+    pub max_amount_ld: i128,
+}
+
+/// Receipt containing amounts sent and received in an OFT transfer
+#[contracttype]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct OFTReceipt {
+    pub amount_sent_ld: i128,
+    pub amount_received_ld: i128,
+}
+
+/// Details about fees charged in an OFT operation
+#[contracttype]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct OFTFeeDetail {
+    pub fee_amount_ld: i128,
+    pub description: Bytes,
+}

package/contracts/oapps/oft/src/utils.rs

@@ -0,0 +1,67 @@
+use soroban_sdk::{address_payload::AddressPayload, assert_with_error, Address, BytesN, Env};
+
+use crate::errors::OFTError;
+
+// =====================================================
+// OFT Helper Functions
+// =====================================================
+
+/// Converts from shared decimals (SD) to local decimals (LD).
+pub fn to_ld(amount_sd: u64, conversion_rate: i128) -> i128 {
+    (amount_sd as i128) * conversion_rate
+}
+
+/// Converts from local decimals (LD) to shared decimals (SD).
+pub fn to_sd(env: &Env, amount_ld: i128, conversion_rate: i128) -> u64 {
+    let amount_sd = amount_ld / conversion_rate;
+    assert_with_error!(env, amount_sd <= u64::MAX as i128, OFTError::Overflow);
+    amount_sd as u64
+}
+
+/// Removes dust from amount based on decimal conversion rate.
+pub fn remove_dust(amount_ld: i128, conversion_rate: i128) -> i128 {
+    (amount_ld / conversion_rate) * conversion_rate
+}
+
+// =====================================================
+// Address Helper Functions
+// =====================================================
+
+/// Extracts the 32-byte payload from an address.
+///
+/// This function extracts the raw 32-byte payload from a Stellar address,
+/// which can be either a contract ID hash or an Ed25519 public key.
+/// This payload can later be resolved back to an address using `resolve_address`.
+///
+/// # Arguments
+/// * `address` - The Stellar address to extract the payload from
+///
+/// # Returns
+/// A 32-byte payload (contract ID hash or Ed25519 public key)
+pub fn address_to_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::ContractIdHash(payload) => payload,
+        AddressPayload::AccountIdPublicKeyEd25519(payload) => payload,
+    }
+}
+
+/// Resolves a 32-byte payload to an address.
+///
+/// This function attempts to convert the 32-byte payload to a contract address first.
+/// If the contract exists, it returns the contract address.
+/// If the contract doesn't exist, it falls back to creating a G-address (account address).
+///
+/// # Arguments
+/// * `env` - The Soroban environment
+/// * `bytes32` - The 32-byte payload to resolve
+///
+/// # Returns
+/// The resolved address (either contract or account address)
+pub fn resolve_address(env: &Env, bytes32: &BytesN<32>) -> Address {
+    let contract_address = Address::from_payload(env, AddressPayload::ContractIdHash(bytes32.clone()));
+    if contract_address.exists() {
+        contract_address
+    } else {
+        Address::from_payload(env, AddressPayload::AccountIdPublicKeyEd25519(bytes32.clone()))
+    }
+}

package/contracts/oapps/oft-mint-burn/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "oft-mint-burn"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+utils = { workspace = true }
+oapp = { workspace = true }
+common-macros = { workspace = true }
+oapp-macros = { workspace = true }
+oft = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+assert_unordered = "0.3.5"
+simple-message-lib = { workspace = true }
+message-lib-common = { workspace = true, features = ["testutils"] }
+endpoint-v2 = { workspace = true, features = ["testutils"] }
+executor = { workspace = true, features = ["testutils"] }

package/contracts/oapps/oft-mint-burn/src/lib.rs

@@ -0,0 +1,3 @@
+#![no_std]
+
+pub mod oft;

package/contracts/oapps/oft-mint-burn/src/oft.rs

@@ -0,0 +1,28 @@
+use oapp_macros::oapp;
+use oft::oft::{oft_initialize, OFTInner, OFT};
+use oft::oft_types::mint_burn;
+use oft::types::OFTReceipt;
+use soroban_sdk::{contractimpl, Address, Env};
+
+#[oapp]
+pub struct OFTMintBurn;
+
+#[contractimpl]
+impl OFTMintBurn {
+    pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+        oft_initialize::<Self>(env, owner, token, endpoint, delegate)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OFT for OFTMintBurn {}
+
+impl OFTInner for OFTMintBurn {
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+    }
+
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+        mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+    }
+}

package/contracts/oapps/oft-mint-burn/src/tests/mod.rs

@@ -0,0 +1 @@
+

package/contracts/utils/src/buffer_reader.rs

@@ -34,9 +34,7 @@ impl<'a> BufferReader<'a> {
         Self { buffer, pos: 0 }
     }
 
-    // TODO: should we pass and return a self instead of mutable reference?
-    /// Sets the absolute position in the buffer.
-    pub fn set_position(&mut self, pos: u32) -> &mut Self {
+    pub fn seek(&mut self, pos: u32) -> &mut Self {
         assert_with_error!(self.buffer.env(), pos <= self.buffer.len(), BufferReaderError::InvalidLength);
         self.pos = pos;
         self
@@ -44,7 +42,7 @@ impl<'a> BufferReader<'a> {
 
     /// Advances the position by `len` bytes without reading.
     pub fn skip(&mut self, len: u32) -> &mut Self {
-        self.set_position(self.pos + len)
+        self.seek(self.pos + len)
     }
 
     /// Moves the position backwards by `len` bytes.
@@ -55,7 +53,7 @@ impl<'a> BufferReader<'a> {
     }
 
     // Generates: read_u8 (1 byte), read_u16 (2 bytes), read_u32 (4 bytes), read_u64 (8 bytes), read_u128 (16 bytes)
-    impl_read_uint!(read_u8, u8, 1; read_u16, u16, 2; read_u32, u32, 4; read_u64, u64, 8; read_u128, u128, 16);
+    impl_read_uint!(read_u8, u8, 1; read_u16, u16, 2; read_u32, u32, 4; read_u64, u64, 8; read_u128, u128, 16; read_i128, i128, 16);
 
     /// Reads a boolean (1 byte, non-zero = true).
     pub fn read_bool(&mut self) -> bool {
@@ -94,9 +92,8 @@ impl<'a> BufferReader<'a> {
         value
     }
 
-    /// Reads all remaining bytes from current position to end.
     pub fn read_bytes_until_end(&mut self) -> Bytes {
-        self.read_bytes(self.remaining())
+        self.read_bytes(self.remaining_len())
     }
 
     /// Returns the current read position.
@@ -120,7 +117,7 @@ impl<'a> BufferReader<'a> {
     }
 
     /// Returns the number of bytes remaining after current position.
-    pub fn remaining(&self) -> u32 {
+    pub fn remaining_len(&self) -> u32 {
         self.buffer.len() - self.pos
     }
 
@@ -129,7 +126,9 @@ impl<'a> BufferReader<'a> {
         self.buffer.env()
     }
 
-    // === Internal Functions ===
+    // ============================================================================================
+    // Internal Functions
+    // ============================================================================================
 
     /// Compose an address from its type byte and 32-byte payload.
     fn compose_address(&self, payload_type: u8, payload: BytesN<32>) -> Address {

package/contracts/utils/src/buffer_writer.rs

@@ -47,7 +47,7 @@ impl BufferWriter {
     }
 
     // Generates: write_u8 (1 byte), write_u16 (2 bytes), write_u32 (4 bytes), write_u64 (8 bytes), write_u128 (16 bytes)
-    impl_write_uint!(write_u8, u8; write_u16, u16; write_u32, u32; write_u64, u64; write_u128, u128);
+    impl_write_uint!(write_u8, u8; write_u16, u16; write_u32, u32; write_u64, u64; write_u128, u128; write_i128, i128);
 
     /// Write a boolean value to the buffer (true as 1, false as 0).
     pub fn write_bool(&mut self, value: bool) -> &mut Self {
@@ -66,6 +66,11 @@ impl BufferWriter {
         self
     }
 
+    pub fn write_array<const N: usize>(&mut self, array: &[u8; N]) -> &mut Self {
+        self.buffer.extend_from_array(array);
+        self
+    }
+
     /// Write a fixed-size BytesN<N> to the buffer.
     pub fn write_bytes_n<const N: usize>(&mut self, bytes_n: &BytesN<N>) -> &mut Self {
         self.buffer.extend_from_array(&bytes_n.to_array());
@@ -85,9 +90,8 @@ impl BufferWriter {
     }
 
     /// Get the complete buffer as a Bytes, consuming the writer.
-    pub fn to_bytes(self) -> Bytes {
-        let Self { buffer } = self;
-        buffer
+    pub fn to_bytes(&self) -> Bytes {
+        self.buffer.clone()
     }
 
     /// Get the current length of the buffer.
@@ -105,7 +109,9 @@ impl BufferWriter {
         self.buffer.env()
     }
 
-    // === Internal Functions ===
+    // ============================================================================================
+    // Internal Functions
+    // ============================================================================================
 
     /// Decompose an address into its type byte and 32-byte payload.
     fn decompose_address(&self, address: &Address) -> (u8, BytesN<32>) {

package/contracts/utils/src/errors.rs

@@ -2,29 +2,29 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum BufferReaderError {
-    InvalidLength = 10000,
+    InvalidLength = 1000,
     InvalidAddressPayload,
 }
 
 #[contract_error]
 pub enum BufferWriterError {
-    InvalidAddressPayload = 10100,
+    InvalidAddressPayload = 1100,
 }
 
 #[contract_error]
 pub enum TtlError {
-    InvalidTtlConfig = 10200,
+    InvalidTtlConfig = 1200,
     TtlConfigFrozen,
     TtlConfigAlreadyFrozen,
 }
 
 #[contract_error]
 pub enum OwnableError {
-    OwnerAlreadySet = 10300,
+    OwnerAlreadySet = 1300,
     OwnerNotSet,
 }
 
 #[contract_error]
 pub enum BytesExtError {
-    LengthMismatch = 10400,
+    LengthMismatch = 1400,
 }

package/contracts/utils/src/ownable.rs

@@ -1,9 +1,18 @@
-use crate as utils;
+use crate::errors::OwnableError;
 use crate::option_ext::OptionExt;
-use crate::{errors::OwnableError, ttl::DefaultTtlConfigProvider};
 use common_macros::{event, storage};
 use soroban_sdk::{assert_with_error, contractclient, Address, Env};
 
+// ============================================
+// Ownable Initializer Interface
+// ============================================
+
+/// Trait for initializing contract ownership.
+pub trait OwnableInitializer {
+    /// Initializes the owner. Should only be called once at contract initialization.
+    fn init_owner(env: &Env, owner: &Address);
+}
+
 // ============================================
 // Ownable Interface
 // ============================================
@@ -55,7 +64,7 @@ pub struct OwnershipRenounced {
 pub struct DefaultOwnable;
 
 /// Storage keys for DefaultOwnable.
-#[storage(DefaultTtlConfigProvider)]
+#[storage]
 pub enum DefaultOwnableStorage {
     #[instance(Address)]
     Owner,
@@ -79,9 +88,8 @@ impl Ownable for DefaultOwnable {
     }
 }
 
-impl DefaultOwnable {
-    /// Initializes the owner. This should only be called once at contract initialization.
-    pub fn init_owner(env: &Env, owner: &Address) {
+impl OwnableInitializer for DefaultOwnable {
+    fn init_owner(env: &Env, owner: &Address) {
         assert_with_error!(env, !DefaultOwnableStorage::has_owner(env), OwnableError::OwnerAlreadySet);
         DefaultOwnableStorage::set_owner(env, owner);
     }

package/contracts/utils/src/testing_utils.rs

@@ -80,12 +80,22 @@ impl<E: Event> IntoExpectedEvent for E {}
 /// ```
 pub fn assert_events(env: &Env, contract: &Address, expected_events: &[ExpectedEvent]) {
     let events = env.events().all();
+    // Track which emitted events have already been matched so that duplicate expectations
+    // require duplicate emissions (multiset semantics).
+    //
+    // Note: this module is only compiled for tests / testutils usage, where `std` is available.
+    extern crate std;
+    let mut used: std::vec::Vec<bool> = std::vec![false; events.len() as usize];
 
     for (i, expected) in expected_events.iter().enumerate() {
         let mut found = false;
-        for (address, topics, data) in events.iter() {
+        for (idx, (address, topics, data)) in events.iter().enumerate() {
+            if used[idx] {
+                continue;
+            }
             if &address == contract && topics_eq(env, &topics, &expected.topics) && data_eq(env, &data, &expected.data)
             {
+                used[idx] = true;
                 found = true;
                 break;
             }