@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

package/contracts/oapps/oft/integration-tests/setup.rs

@@ -1,141 +1,39 @@
-//! Integration test setup for OFT.
+//! Integration test setup for OFT-STD with real EndpointV2 and SimpleMessageLib.
 //!
-//! This file contains TestOFT contract and test setup utilities.
+//! This file contains test setup utilities for OFT-STD with all extensions enabled.
 
-extern crate self as oft;
 extern crate std;
 
-use crate::integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address};
-use common_macros::contract_impl;
-use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer, Origin};
-use oapp::oapp_receiver::LzReceiveInternal;
-use oft::{
-    initialize_oft,
-    oft::{OFTClient, OFTInternal, OFT},
-    oft_impl,
-    storage::OFTStorage,
-    types::OFTReceipt,
+use crate::{
+    integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
+    oft::{OFTClient, OFT},
+    oft_types::OftType,
 };
+use endpoint_v2::{EndpointV2, EndpointV2Client};
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
 use soroban_sdk::{
-    contract, contractimpl, contracttype, log, symbol_short,
+    contract, contractimpl, log,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::{StellarAssetClient, TokenClient},
-    Address, Bytes, BytesN, Env, IntoVal,
+    token::TokenClient,
+    Address, BytesN, Env, IntoVal,
 };
 
 // ============================================================================
-// Test OFT Contract
+// Dummy Recipient - used to create valid contract addresses for recipients
 // ============================================================================
 
-#[oapp_macros::oapp]
-pub struct TestOFT;
-
-impl LzReceiveInternal for TestOFT {
-    fn __lz_receive(
-        env: &Env,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        extra_data: &Bytes,
-        executor: &Address,
-        value: i128,
-    ) {
-        oft_impl::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
-    }
-}
-
-#[contract_impl]
-impl TestOFT {
-    pub fn __constructor(
-        env: &Env,
-        token: &Address,
-        owner: &Address,
-        endpoint: &Address,
-        delegate: &Option<Address>,
-        shared_decimals: u32,
-    ) {
-        initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
-    }
-}
-
-#[contractimpl(contracttrait)]
-impl OFT for TestOFT {}
-
-impl OFTInternal for TestOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        // Get the receipt (handles decimal conversion, fees, etc.)
-        let receipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-        // Actually burn tokens from sender
-        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).burn(sender, &receipt.amount_sent_ld);
-        receipt
-    }
-
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-        // Actually mint tokens to recipient
-        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).mint(to, &amount_ld);
-        amount_ld
-    }
-}
-
-// ============================================================================
-// Dummy Composer for testing compose messages
-// ============================================================================
-
-#[contracttype]
-pub struct ComposeMessage {
-    pub executor: Address,
-    pub from: Address,
-    pub guid: BytesN<32>,
-    pub index: u32,
-    pub message: Bytes,
-    pub extra_data: Bytes,
-    pub value: i128,
-}
-
 #[contract]
-pub struct DummyComposer;
+pub struct DummyRecipient;
 
-#[contract_impl]
-impl DummyComposer {
-    pub fn __constructor(env: &Env, endpoint: &Address) {
-        env.storage().instance().set(&symbol_short!("endpoint"), endpoint);
-    }
-
-    pub fn compose_message(env: &Env) -> Option<ComposeMessage> {
-        env.storage().instance().get(&symbol_short!("msg"))
-    }
+#[contractimpl]
+impl DummyRecipient {
+    pub fn __constructor(_env: &Env) {}
 }
 
-#[contract_impl]
-impl ILayerZeroComposer for DummyComposer {
-    fn lz_compose(
-        env: &Env,
-        executor: &Address,
-        from: &Address,
-        guid: &BytesN<32>,
-        index: u32,
-        message: &Bytes,
-        extra_data: &Bytes,
-        value: i128,
-    ) {
-        let endpoint_address: Address = env.storage().instance().get(&symbol_short!("endpoint")).unwrap();
-        let endpoint = endpoint_v2::MessagingComposerClient::new(env, &endpoint_address);
-        endpoint.clear_compose(&env.current_contract_address(), from, guid, &index, message);
-
-        env.storage().instance().set(
-            &symbol_short!("msg"),
-            &ComposeMessage {
-                executor: executor.clone(),
-                from: from.clone(),
-                guid: guid.clone(),
-                index,
-                message: message.clone(),
-                extra_data: extra_data.clone(),
-                value,
-            },
-        );
-    }
+/// Creates a valid recipient address by deploying a dummy contract.
+/// Use this in tests when the address needs to pass the `.exists()` check.
+pub fn create_recipient_address(env: &Env) -> Address {
+    env.register(DummyRecipient, ())
 }
 
 // ============================================================================
@@ -146,16 +44,16 @@ pub struct ChainSetup<'a> {
     pub eid: u32,
     pub owner: Address,
     pub native_token: Address,
+    pub zro_token: Address,
     pub oft_token: Address,
     pub endpoint: EndpointV2Client<'a>,
     pub sml: SimpleMessageLibClient<'a>,
     pub oft: OFTClient<'a>,
-    pub composer: DummyComposerClient<'a>,
+    pub fee_collector: Address,
 }
 
 pub struct TestSetup<'a> {
     pub env: Env,
-
     pub chain_a: ChainSetup<'a>,
     pub chain_b: ChainSetup<'a>,
 }
@@ -163,9 +61,13 @@ pub struct TestSetup<'a> {
 fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let owner = Address::generate(env);
 
+    // Create native token FIRST - this must match the endpoint's NATIVE_TOKEN constant
     let sac = env.register_stellar_asset_contract_v2(owner.clone());
     let native_token = sac.address();
 
+    // Generate fee_collector AFTER native_token to not affect the address derivation
+    let fee_collector = Address::generate(env);
+
     // Create ZRO token
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
@@ -179,13 +81,12 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
     let shared_decimals: u32 = 6; // Default shared decimals
-    let oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals));
-    let composer_address = env.register(DummyComposer, (&endpoint_address,));
+    let mode = OftType::MintBurn;
+    let oft_address = env.register(OFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals, &mode));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);
     let oft = OFTClient::new(env, &oft_address);
-    let composer = DummyComposerClient::new(env, &composer_address);
 
     // Set ZRO token in endpoint
     env.mock_auths(&[MockAuth {
@@ -202,7 +103,7 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     register_library(env, &owner, &endpoint, &sml.address);
 
     let eid = endpoint.eid();
-    ChainSetup { eid, owner, native_token, oft_token, endpoint, sml, oft, composer }
+    ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
 }
 
 pub fn setup<'a>() -> TestSetup<'a> {

package/contracts/oapps/oft/integration-tests/utils.rs

@@ -1,20 +1,22 @@
-use core::ops::Mul;
+//! Utility functions for OFT-STD integration tests.
 
-use crate::{
-    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec},
-    integration_tests::setup::{decode_packet, ChainSetup},
-    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-};
+use crate::extensions::rate_limiter::Direction;
+use crate::integration_tests::setup::{decode_packet, ChainSetup};
 use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
 use message_lib_common::packet_codec_v1;
+use oft_core::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
 use soroban_sdk::{
     address_payload::AddressPayload,
-    testutils::{Events, MockAuth, MockAuthInvoke},
+    testutils::{Events, Ledger, MockAuth, MockAuthInvoke},
     token::StellarAssetClient,
     xdr::ToXdr,
     Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
 };
 
+// ============================================================================
+// Address Conversion Utilities
+// ============================================================================
+
 pub fn address_to_peer_bytes32(address: &Address) -> BytesN<32> {
     match address.to_payload().unwrap() {
         AddressPayload::ContractIdHash(payload) => payload,
@@ -26,6 +28,16 @@ pub fn peer_bytes32_to_address(env: &Env, bytes32: &BytesN<32>) -> Address {
     AddressPayload::ContractIdHash(bytes32.clone()).to_address(env)
 }
 
+#[allow(dead_code)]
+pub fn create_recipient_address(env: &Env) -> Address {
+    let bytes = BytesN::from_array(env, &[0u8; 32]);
+    peer_bytes32_to_address(env, &bytes)
+}
+
+// ============================================================================
+// OFT Core Operations
+// ============================================================================
+
 pub fn quote_oft(chain: &ChainSetup<'_>, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
     chain.oft.quote_oft(send_param)
 }
@@ -49,6 +61,7 @@ pub fn quote_send(
     chain.oft.quote_send(sender, send_param, &pay_in_zro)
 }
 
+/// Send without fee (standard OFT send)
 pub fn send(
     env: &Env,
     chain: &ChainSetup<'_>,
@@ -83,6 +96,88 @@ pub fn send(
     chain.oft.send(sender, send_param, fee, refund_address);
 }
 
+/// Send with fee (OFT fee extension enabled)
+/// Order: transfer fee to deposit -> burn tokens -> transfer native fee
+pub fn send_with_fee(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+    fee_deposit_address: &Address,
+) {
+    let fee_amount = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "transfer",
+                    args: (sender, fee_deposit_address, &fee_amount).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.send(sender, send_param, fee, refund_address);
+}
+
+pub fn try_send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+) -> bool {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.try_send(sender, send_param, fee, refund_address).is_ok()
+}
+
+// ============================================================================
+// Packet Handling
+// ============================================================================
+
 pub fn validate_packet(env: &Env, chain: &ChainSetup<'_>, packet_event: &(Bytes, Bytes, Address)) {
     let packet = decode_packet(env, &packet_event.0);
     let encoded_header = packet_codec_v1::encode_packet_header(env, &packet);
@@ -131,26 +226,30 @@ pub fn lz_receive(
     );
 }
 
-pub fn lz_compose(
+pub fn try_lz_receive(
     env: &Env,
     chain: &ChainSetup<'_>,
     executor: &Address,
     packet: &OutboundPacket,
-    index: u32,
-    extra_data: &Bytes,
+    recipient: &Address,
     value: i128,
-) {
-    let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
-    let oft_compose_msg = OFTComposeMsg {
-        nonce: packet.nonce,
-        src_eid: packet.src_eid,
-        amount_ld: (oft_msg.amount_sd as i128).mul(chain.oft.decimal_conversion_rate()),
-        compose_from: oft_msg.compose_from.unwrap(),
-        compose_msg: oft_msg.compose_msg.unwrap(),
-    }
-    .encode(&env);
+) -> bool {
+    let origin =
+        Origin { src_eid: packet.src_eid, sender: address_to_peer_bytes32(&packet.sender), nonce: packet.nonce };
+    let extra_options = recipient.to_xdr(env);
 
-    chain.composer.lz_compose(executor, &chain.oft.address, &packet.guid, &index, &oft_compose_msg, extra_data, &value);
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &extra_options, &value).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_v2::LayerZeroReceiverClient::new(env, &chain.oft.address)
+        .try_lz_receive(executor, &origin, &packet.guid, &packet.message, &extra_options, &value)
+        .is_ok()
 }
 
 // returns (encoded_payload, options, send_library)
@@ -172,6 +271,10 @@ pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, B
     packet
 }
 
+// ============================================================================
+// Token Operations
+// ============================================================================
+
 pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount: i128) {
     env.mock_auths(&[MockAuth {
         address: owner,
@@ -199,3 +302,133 @@ pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin
     }]);
     StellarAssetClient::new(env, token).set_admin(new_admin);
 }
+
+pub fn token_balance(env: &Env, token: &Address, account: &Address) -> i128 {
+    soroban_sdk::token::TokenClient::new(env, token).balance(account)
+}
+
+// ============================================================================
+// Pausable Extension Operations
+// ============================================================================
+
+pub fn set_paused(env: &Env, chain: &ChainSetup<'_>, paused: bool) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_paused",
+            args: (&paused,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_paused(&paused);
+}
+
+pub fn is_paused(chain: &ChainSetup<'_>) -> bool {
+    chain.oft.is_paused()
+}
+
+// ============================================================================
+// OFT Fee Extension Operations
+// ============================================================================
+
+pub fn set_fee_deposit_address(env: &Env, chain: &ChainSetup<'_>, deposit_address: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_fee_deposit_address",
+            args: (deposit_address,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_fee_deposit_address(deposit_address);
+}
+
+pub fn set_default_fee_bps(env: &Env, chain: &ChainSetup<'_>, fee_bps: u64) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_default_fee_bps",
+            args: (&fee_bps,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_default_fee_bps(&fee_bps);
+}
+
+pub fn set_fee_bps(env: &Env, chain: &ChainSetup<'_>, dst_eid: u32, fee_bps: u64) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_fee_bps",
+            args: (&dst_eid, &fee_bps).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_fee_bps(&dst_eid, &fee_bps);
+}
+
+// ============================================================================
+// Rate Limiter Extension Operations
+// ============================================================================
+
+pub fn set_rate_limit(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    direction: &Direction,
+    dst_eid: u32,
+    limit: i128,
+    window_seconds: u64,
+) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_rate_limit",
+            args: (direction, &dst_eid, &limit, &window_seconds).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_rate_limit(direction, &dst_eid, &limit, &window_seconds);
+}
+
+pub fn rate_limit_capacity(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {
+    chain.oft.rate_limit_capacity(direction, &eid)
+}
+
+pub fn rate_limit_in_flight(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {
+    chain.oft.rate_limit_in_flight(direction, &eid)
+}
+
+// ============================================================================
+// Time Utilities
+// ============================================================================
+
+pub fn advance_time(env: &Env, seconds: u64) {
+    let current = env.ledger().timestamp();
+    env.ledger().set_timestamp(current + seconds);
+}
+
+#[allow(dead_code)]
+pub fn set_timestamp(env: &Env, timestamp: u64) {
+    env.ledger().set_timestamp(timestamp);
+}
+
+// ============================================================================
+// SendParam Builder
+// ============================================================================
+
+pub fn create_send_param(env: &Env, dst_eid: u32, amount_ld: i128, min_amount_ld: i128, to: &BytesN<32>) -> SendParam {
+    SendParam {
+        dst_eid,
+        to: to.clone(),
+        amount_ld,
+        min_amount_ld,
+        extra_options: Bytes::new(env),
+        compose_msg: Bytes::new(env),
+        oft_cmd: Bytes::new(env),
+    }
+}

package/contracts/oapps/oft/src/extensions/oft_fee.rs

@@ -6,6 +6,10 @@ use utils::{option_ext::OptionExt, ownable::Ownable};
 /// Used as denominator in fee calculations
 const BASE_FEE_BPS: u64 = 10_000;
 
+// =========================================================================
+// Storage
+// =========================================================================
+
 #[storage]
 pub enum OFTFeeStorage {
     #[instance(u64)]
@@ -19,14 +23,22 @@ pub enum OFTFeeStorage {
     FeeDepositAddress,
 }
 
+// =========================================================================
+// Errors
+// =========================================================================
+
 #[contract_error]
 pub enum OFTFeeError {
-    InvalidFeeBps = 2200,
+    InvalidFeeBps = 3100,
     InvalidFeeDepositAddress,
     NotFound,
     SameValue,
 }
 
+// =========================================================================
+// Events
+// =========================================================================
+
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DefaultFeeBpsSet {
@@ -52,8 +64,12 @@ pub struct FeeDepositAddressSet {
     pub fee_deposit_address: Address,
 }
 
+// =========================================================================
+// Trait With Default Implementations
+// =========================================================================
+
 #[contract_trait]
-pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
+pub trait OFTFee: OFTFeeInternal + Ownable {
     #[only_auth]
     fn set_default_fee_bps(env: &Env, default_fee_bps: u64) {
         assert_with_error!(env, default_fee_bps <= BASE_FEE_BPS, OFTFeeError::InvalidFeeBps);
@@ -118,15 +134,15 @@ pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
 /// Internal trait for OFT fee operations used by OFT hooks.
 /// Contains only truly internal methods that are called from OFTInner implementations.
 pub trait OFTFeeInternal {
-    /// Calculates the amount after fee deduction (read-only, mirrors `__debit_view`).
-    /// Used internally by `__debit_view` to calculate amount after fee.
+    /// Calculates the fee amount for a given transfer (read-only).
+    /// Used internally by `__debit_view` to calculate the fee.
     ///
     /// # Arguments
     /// * `dst_eid` - Destination endpoint ID to determine which fee rate to apply
     /// * `amount_ld` - The original amount in local decimals
     ///
     /// # Returns
-    /// The amount after fee deduction (original amount - calculated fee)
+    /// The fee amount to be deducted
     fn __fee_view(env: &Env, dst_eid: u32, amount_ld: i128) -> i128 {
         // Calculate effective fee (destination-specific or default)
         let fee_bps = if OFTFeeStorage::has_fee_bps(env, dst_eid) {
@@ -135,7 +151,7 @@ pub trait OFTFeeInternal {
             OFTFeeStorage::default_fee_bps(env)
         };
         if fee_bps == 0 {
-            return amount_ld;
+            return 0;
         }
         // Check that fee deposit address is set (required for fee collection)
         assert_with_error!(
@@ -143,8 +159,7 @@ pub trait OFTFeeInternal {
             OFTFeeStorage::fee_deposit_address(env).is_some(),
             OFTFeeError::InvalidFeeDepositAddress
         );
-        let preliminary_fee = (amount_ld * fee_bps as i128) / BASE_FEE_BPS as i128;
-        amount_ld - preliminary_fee
+        (amount_ld * fee_bps as i128) / BASE_FEE_BPS as i128
     }
 
     /// Charges the fee by transferring the fee amount from sender to the fee deposit address.

package/contracts/oapps/oft/src/extensions/pausable.rs

@@ -2,6 +2,10 @@ use common_macros::{contract_error, contract_trait, only_auth, storage};
 use soroban_sdk::{assert_with_error, contractevent, Env};
 use utils::ownable::Ownable;
 
+// =========================================================================
+// Storage
+// =========================================================================
+
 #[storage]
 pub enum OFTPausableStorage {
     #[instance(bool)]
@@ -9,24 +13,35 @@ pub enum OFTPausableStorage {
     Paused,
 }
 
+// =========================================================================
+// Errors
+// =========================================================================
+
 #[contract_error]
 pub enum OFTPausableError {
-    Paused = 2300,
+    Paused = 3110,
     PauseStatusUnchanged,
 }
 
+// =========================================================================
+// Events
+// =========================================================================
+
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PausedSet {
     pub paused: bool,
 }
 
+// =========================================================================
+// Trait With Default Implementations
+// =========================================================================
+
 #[contract_trait]
-pub trait OFTPausable: OFTPausableInternal + Ownable + Sized {
+pub trait OFTPausable: OFTPausableInternal + Ownable {
     #[only_auth]
     fn set_paused(env: &Env, paused: bool) {
-        let current_paused = OFTPausableStorage::paused(env);
-        assert_with_error!(env, current_paused != paused, OFTPausableError::PauseStatusUnchanged);
+        assert_with_error!(env, Self::is_paused(env) != paused, OFTPausableError::PauseStatusUnchanged);
         OFTPausableStorage::set_paused(env, &paused);
         PausedSet { paused }.publish(env);
     }