git_diff.patch

diff --git a/src/audit_summary_tests.rs b/src/audit_summary_tests.rs
index 536005d..48bbbc0 100644
--- a/src/audit_summary_tests.rs
+++ b/src/audit_summary_tests.rs
@@ -21,7 +21,7 @@ fn setup_offering() -> (Env, Address, Address, Address, Address) {
     let payout_asset = Address::generate(&env);
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     (env, contract_id, issuer, token, payout_asset)
 }
diff --git a/src/chunking_tests.rs b/src/chunking_tests.rs
index 17f5bb0..bc87acd 100644
--- a/src/chunking_tests.rs
+++ b/src/chunking_tests.rs
@@ -36,7 +36,7 @@ fn setup_with_offering() -> (Env, RevoraRevenueShareClient, Address, Address, Ad
     let token = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
     // Register offering and fund issuer so deposit_revenue can transfer tokens
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payment_token, &0, &None);
     mint_tokens(&env, &payment_token, &issuer, &100_000i128);
     (env, client, issuer, token, payment_token, pt_admin)
 }
@@ -50,7 +50,7 @@ fn get_revenue_range_chunk_matches_full_sum() {
 
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128, &None);
 
     // Report revenue for periods 1..=10
     for p in 1u64..=10u64 {
@@ -92,7 +92,7 @@ fn get_revenue_range_chunk_inverted_range_returns_zero() {
 
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128, &None);
 
     // inverted range: from > to
     let (sum, next) = client.get_revenue_range_chunk(&issuer, &symbol_short!("def"), &token, &10u64, &1u64, &5u32);
@@ -112,7 +112,7 @@ fn get_revenue_range_chunk_cap_clamps_and_returns_next_start() {
 
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128, &None);
 
     // Report revenue for periods 1..=201 with amount 1 each
     for p in 1u64..=201u64 {
@@ -143,7 +143,7 @@ fn get_revenue_range_chunk_chunked_iteration_off_by_one_sequence() {
 
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000u32, &token, &0i128, &None);
 
     // Report revenue for periods 1..=5 with increasing amounts for easier validation
     for p in 1u64..=5u64 {
@@ -201,7 +201,7 @@ fn pending_periods_page_and_claimable_chunk_consistent() {
         &1000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
     // Mint to issuer so deposit_revenue token transfer succeeds
     mint_tokens(&env, &payment_token, &issuer, &100_000i128);
 
@@ -326,7 +326,7 @@ fn get_claimable_chunk_table_driven_invariants() {
         &1000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
     mint_tokens(&env, &payment_token, &issuer, &100_000i128);
 
     let test_cases = vec![
@@ -509,7 +509,7 @@ fn get_claimable_chunk_table_driven_invariants() {
             &1000u32,
             &payment_token,
             &0i128,
-        );
+        , &None);
         mint_tokens(&env, &payment_token, &issuer, &100_000i128);
 
         // Set up test case conditions
@@ -613,7 +613,7 @@ fn get_claimable_chunk_cursor_idempotency_repeated_queries() {
         &1000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
     mint_tokens(&env, &payment_token, &issuer, &100_000i128);
 
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &10_000);
@@ -685,7 +685,7 @@ fn get_claimable_chunk_sum_matches_full_claimable() {
         &1000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
     mint_tokens(&env, &payment_token, &issuer, &100_000i128);
 
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &5_000);
@@ -748,7 +748,7 @@ fn get_claimable_chunk_respects_delay_barrier_parity_with_claim() {
         &1000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
     mint_tokens(&env, &payment_token, &issuer, &100_000i128);
 
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &10_000);
diff --git a/src/invalid_amount_matrix_tests.rs b/src/invalid_amount_matrix_tests.rs
index 1d176d8..72da013 100644
--- a/src/invalid_amount_matrix_tests.rs
+++ b/src/invalid_amount_matrix_tests.rs
@@ -38,7 +38,7 @@ fn setup_offering() -> (Env, Address, Address, Address, Address) {
         &1_000,
         &payout_asset,
         &0,
-    );
+    , &None);
 
     (env, contract_id, issuer, token, payout_asset)
 }
@@ -60,7 +60,7 @@ fn setup_funded_offering() -> (Env, Address, Address, Address, Address) {
         &1_000,
         &payment_token,
         &0,
-    );
+    , &None);
     mint(&env, &payment_token, &issuer, 1_000_000);
 
     (env, contract_id, issuer, token, payment_token)
@@ -92,7 +92,7 @@ fn register_offering_rejects_negative_supply_cap_values() {
             &1_000,
             &payout_asset,
             &invalid_cap,
-        );
+        , &None);
         assert_eq!(result, Err(Ok(RevoraError::InvalidAmount)));
         assert_eq!(client.get_offering_count(&issuer, &symbol_short!("def")), 0);
         assert!(client.get_offering(&issuer, &symbol_short!("def"), &token).is_none());
diff --git a/src/lib.rs b/src/lib.rs
index afd6a61..f405a6b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -167,8 +167,12 @@ pub enum RevoraError {
 
     /// The period has been sealed by `close_period`; no further overrides are accepted.
     ///
-    /// Wire value: 48. Stable since v1.
-    PeriodAlreadyClosed = 48,
+    /// Wire value: 53. Stable since v1.
+    PeriodAlreadyClosed = 53,
+    /// The specified share class is invalid or does not exist for the offering.
+    InvalidShareClass = 51,
+    /// The total BPS allocations across all share classes must sum to exactly 10,000.
+    InvalidShareClassBps = 52,
 }
 
 pub mod vesting;
@@ -381,6 +385,21 @@ pub struct OfferingId {
     pub token: Address,
 }
 
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ShareClass {
+    A,
+    B,
+    Custom(Symbol),
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassConfig {
+    pub bps: u32,
+    pub voting: bool,
+}
+
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
 pub struct Offering {
@@ -767,6 +786,13 @@ pub enum DataKey2 {
 
     /// Sealed-period flag: when present, `report_revenue` overrides are rejected for this period.
     ClosedPeriod(OfferingId, u64),
+
+    /// Configurations of share classes for an offering.
+    OfferingClasses(OfferingId),
+    /// Share basis points for a holder in a specific share class of an offering.
+    HolderShareClass(OfferingId, Address, ShareClass),
+    /// Total share basis points allocated to all holders in a specific share class.
+    HolderShareClassTotal(OfferingId, ShareClass),
 }
 
 /// Maximum number of offerings returned in a single page.
@@ -1226,6 +1252,7 @@ impl RevoraRevenueShare {
         token: Address,
         holder: Address,
         share_bps: u32,
+        share_class: Option<ShareClass>,
     ) -> Result<(), RevoraError> {
         if share_bps > 10_000 {
             return Err(RevoraError::InvalidShareBps);
@@ -1236,26 +1263,65 @@ impl RevoraRevenueShare {
             token: token.clone(),
         };
 
-        // Maintain a running total of persisted holder shares for this offering.
-        let total_key = DataKey::HolderShareTotal(offering_id.clone());
-        let mut current_total: u32 = env.storage().persistent().get(&total_key).unwrap_or(0);
+        let classes_key = DataKey2::OfferingClasses(offering_id.clone());
+        let classes: Option<Vec<(ShareClass, ClassConfig)>> = env.storage().persistent().get(&classes_key);
 
-        let old_share: u32 = env
-            .storage()
-            .persistent()
-            .get(&DataKey::HolderShare(offering_id.clone(), holder.clone()))
-            .unwrap_or(0);
+        match classes {
+            Some(cls_vec) => {
+                let sc = match share_class {
+                    Some(sc) => sc,
+                    None => return Err(RevoraError::InvalidShareClass),
+                };
+                let mut found = false;
+                for (class_name, _) in cls_vec.iter() {
+                    if class_name == sc {
+                        found = true;
+                        break;
+                    }
+                }
+                if !found {
+                    return Err(RevoraError::InvalidShareClass);
+                }
 
-        let new_total = current_total.saturating_sub(old_share).saturating_add(share_bps);
-        if new_total > 10_000 {
-            return Err(RevoraError::InvalidShareBps);
-        }
+                let class_share_key = DataKey2::HolderShareClass(offering_id.clone(), holder.clone(), sc.clone());
+                let old_share: u32 = env.storage().persistent().get(&class_share_key).unwrap_or(0);
+                let total_class_key = DataKey2::HolderShareClassTotal(offering_id.clone(), sc.clone());
+                let current_class_total: u32 = env.storage().persistent().get(&total_class_key).unwrap_or(0);
 
-        // Persist updated holder share and running total.
-        env.storage()
-            .persistent()
-            .set(&DataKey::HolderShare(offering_id.clone(), holder.clone()), &share_bps);
-        env.storage().persistent().set(&total_key, &new_total);
+                let new_total = current_class_total.saturating_sub(old_share).saturating_add(share_bps);
+                if new_total > 10_000 {
+                    return Err(RevoraError::InvalidShareBps);
+                }
+
+                env.storage().persistent().set(&class_share_key, &share_bps);
+                env.storage().persistent().set(&total_class_key, &new_total);
+            }
+            None => {
+                if share_class.is_some() {
+                    return Err(RevoraError::InvalidShareClass);
+                }
+                // Maintain a running total of persisted holder shares for this offering.
+                let total_key = DataKey::HolderShareTotal(offering_id.clone());
+                let mut current_total: u32 = env.storage().persistent().get(&total_key).unwrap_or(0);
+
+                let old_share: u32 = env
+                    .storage()
+                    .persistent()
+                    .get(&DataKey::HolderShare(offering_id.clone(), holder.clone()))
+                    .unwrap_or(0);
+
+                let new_total = current_total.saturating_sub(old_share).saturating_add(share_bps);
+                if new_total > 10_000 {
+                    return Err(RevoraError::InvalidShareBps);
+                }
+
+                // Persist updated holder share and running total.
+                env.storage()
+                    .persistent()
+                    .set(&DataKey::HolderShare(offering_id.clone(), holder.clone()), &share_bps);
+                env.storage().persistent().set(&total_key, &new_total);
+            }
+        }
 
         env.events().publish(
             (EVENT_SHARE_SET, issuer.clone(), namespace.clone(), token.clone()),
@@ -2349,11 +2415,22 @@ impl RevoraRevenueShare {
         revenue_share_bps: u32,
         payout_asset: Address,
         supply_cap: i128,
+        classes: Option<Vec<(ShareClass, ClassConfig)>>,
     ) -> Result<(), RevoraError> {
         Self::require_not_frozen(&env)?;
         Self::require_not_paused(&env)?;
         issuer.require_auth();
 
+        if let Some(ref cls_vec) = classes {
+            let mut sum_bps: u32 = 0;
+            for (_, config) in cls_vec.iter() {
+                sum_bps = sum_bps.checked_add(config.bps).ok_or(RevoraError::InvalidShareClassBps)?;
+            }
+            if sum_bps != 10_000 {
+                return Err(RevoraError::InvalidShareClassBps);
+            }
+        }
+
         // Negative Amount Validation Matrix: SupplyCap requires >= 0 (#163)
         if let Err((err, _)) =
             AmountValidationMatrix::validate(supply_cap, AmountValidationCategory::SupplyCap)
@@ -2420,6 +2497,10 @@ impl RevoraRevenueShare {
             env.storage().persistent().set(&cap_key, &supply_cap);
         }
 
+        if let Some(ref cls_vec) = classes {
+            env.storage().persistent().set(&DataKey2::OfferingClasses(offering_id.clone()), cls_vec);
+        }
+
         Self::emit_v2_event(
             &env,
             (EVENT_OFFER_REG_V2, issuer.clone(), namespace.clone()),
@@ -5175,7 +5256,36 @@ impl RevoraRevenueShare {
 
         // Delegate to internal writer which maintains the aggregate running total
         // and enforces the per-offering sum invariant (≤ 10_000 bps).
-        Self::set_holder_share_internal(&env, issuer, namespace, token, holder, share_bps)
+        Self::set_holder_share_internal(&env, issuer, namespace, token, holder, share_bps, None)
+    }
+
+    /// Set a holder's revenue share in basis points for a specific class of an offering.
+    pub fn set_holder_share_class(
+        env: Env,
+        issuer: Address,
+        namespace: Symbol,
+        token: Address,
+        holder: Address,
+        share_bps: u32,
+        share_class: ShareClass,
+    ) -> Result<(), RevoraError> {
+        Self::require_not_frozen(&env)?;
+        Self::require_not_paused(&env)?;
+        issuer.require_auth();
+        let offering_id = OfferingId {
+            issuer: issuer.clone(),
+            namespace: namespace.clone(),
+            token: token.clone(),
+        };
+        Self::get_current_issuer(
+            &env,
+            issuer.clone(),
+            offering_id.namespace.clone(),
+            offering_id.token.clone(),
+        )
+        .ok_or(RevoraError::OfferingNotFound)?;
+
+        Self::set_holder_share_internal(&env, issuer, namespace, token, holder, share_bps, Some(share_class))
     }
 
     /// Get a holder's revenue share in basis points for an offering.
@@ -5187,7 +5297,33 @@ impl RevoraRevenueShare {
         holder: Address,
     ) -> u32 {
         let offering_id = OfferingId { issuer, namespace, token };
-        env.storage().persistent().get(&DataKey::HolderShare(offering_id, holder)).unwrap_or(0)
+        let classes_key = DataKey2::OfferingClasses(offering_id.clone());
+        if let Some(cls_vec) = env.storage().persistent().get::<_, Vec<(ShareClass, ClassConfig)>>(&classes_key) {
+            let mut total_share = 0;
+            for (sc, _) in cls_vec.iter() {
+                let share: u32 = env.storage().persistent().get(&DataKey2::HolderShareClass(offering_id.clone(), holder.clone(), sc)).unwrap_or(0);
+                total_share += share;
+            }
+            total_share
+        } else {
+            env.storage().persistent().get(&DataKey::HolderShare(offering_id, holder)).unwrap_or(0)
+        }
+    }
+
+    /// Get a holder's revenue share in basis points for a specific class of an offering.
+    pub fn get_holder_share_class(
+        env: Env,
+        issuer: Address,
+        namespace: Symbol,
+        token: Address,
+        holder: Address,
+        share_class: ShareClass,
+    ) -> u32 {
+        let offering_id = OfferingId { issuer, namespace, token };
+        env.storage()
+            .persistent()
+            .get(&DataKey2::HolderShareClass(offering_id, holder, share_class))
+            .unwrap_or(0)
     }
 
     /// Set the claim delay in seconds for an offering.
@@ -5419,7 +5555,31 @@ impl RevoraRevenueShare {
                 offering_id.token.clone(),
             );
             let normalized = Self::normalize_amount(revenue, decimals);
-            let payout = normalized * (share_bps as i128) / 10_000;
+            let classes_key = DataKey2::OfferingClasses(offering_id.clone());
+            let classes: Option<Vec<(ShareClass, ClassConfig)>> = env.storage().persistent().get(&classes_key);
+            let rounding_mode = Self::get_rounding_mode(
+                env.clone(),
+                offering_id.issuer.clone(),
+                offering_id.namespace.clone(),
+                offering_id.token.clone(),
+            );
+
+            let payout = if classes.is_some() {
+                let mut p = 0_i128;
+                if let Some(ref cls_vec) = classes {
+                    for (sc, config) in cls_vec.iter() {
+                        let holder_share = env.storage().persistent().get(&DataKey2::HolderShareClass(offering_id.clone(), holder.clone(), sc.clone())).unwrap_or(0);
+                        if holder_share > 0 {
+                            let class_rev = Self::compute_share(env.clone(), normalized, config.bps, rounding_mode.clone());
+                            let holder_payout = Self::compute_share(env.clone(), class_rev, holder_share, rounding_mode.clone());
+                            p = p.saturating_add(holder_payout);
+                        }
+                    }
+                }
+                p
+            } else {
+                normalized * (share_bps as i128) / 10_000
+            };
             total_payout += payout;
             claimed_periods.push_back(period_id);
             last_claimed_idx = i + 1;
@@ -5579,6 +5739,7 @@ impl RevoraRevenueShare {
         token: Address,
         holder: Address,
         share_bps: u32,
+        share_class: Option<ShareClass>,
     ) -> Result<(), RevoraError> {
         Self::require_not_frozen(&env)?;
 
@@ -5605,6 +5766,7 @@ impl RevoraRevenueShare {
             offering_id.token,
             holder,
             share_bps,
+            share_class,
         )
     }
 
@@ -5971,12 +6133,31 @@ impl RevoraRevenueShare {
                 offering_id.token.clone(),
             );
             let normalized = Self::normalize_amount(revenue, decimals);
-            total = total.saturating_add(Self::compute_share(
-                env.clone(),
-                normalized,
-                share_bps,
-                RoundingMode::Truncation,
-            ));
+            let classes_key = DataKey2::OfferingClasses(offering_id.clone());
+            let classes: Option<Vec<(ShareClass, ClassConfig)>> = env.storage().persistent().get(&classes_key);
+
+            let payout = if classes.is_some() {
+                let mut p = 0_i128;
+                if let Some(ref cls_vec) = classes {
+                    for (sc, config) in cls_vec.iter() {
+                        let holder_share = env.storage().persistent().get(&DataKey2::HolderShareClass(offering_id.clone(), holder.clone(), sc.clone())).unwrap_or(0);
+                        if holder_share > 0 {
+                            let class_rev = Self::compute_share(env.clone(), normalized, config.bps, RoundingMode::Truncation);
+                            let holder_payout = Self::compute_share(env.clone(), class_rev, holder_share, RoundingMode::Truncation);
+                            p = p.saturating_add(holder_payout);
+                        }
+                    }
+                }
+                p
+            } else {
+                Self::compute_share(
+                    env.clone(),
+                    normalized,
+                    share_bps,
+                    RoundingMode::Truncation,
+                )
+            };
+            total = total.saturating_add(payout);
             processed = processed.saturating_add(1);
             idx = idx.saturating_add(1);
         }
@@ -6228,6 +6409,13 @@ impl RevoraRevenueShare {
         amount: i128,
         holder_shares: Vec<(Address, u32)>,
     ) -> SimulateDistributionResult {
+        let offering_id = OfferingId {
+            issuer: issuer.clone(),
+            namespace: namespace.clone(),
+            token: token.clone(),
+        };
+        let classes_key = DataKey2::OfferingClasses(offering_id.clone());
+        let classes: Option<Vec<(ShareClass, ClassConfig)>> = env.storage().persistent().get(&classes_key);
         let mode = Self::get_rounding_mode(env.clone(), issuer, namespace, token.clone());
         let mut total: i128 = 0;
         let mut payouts = Vec::new(&env);
@@ -6236,7 +6424,22 @@ impl RevoraRevenueShare {
             let payout = if share_bps > 10_000 {
                 0_i128
             } else {
-                Self::compute_share(env.clone(), amount, share_bps, mode)
+                if classes.is_some() {
+                    let mut p = 0_i128;
+                    if let Some(ref cls_vec) = classes {
+                        for (sc, config) in cls_vec.iter() {
+                            let holder_share = env.storage().persistent().get(&DataKey2::HolderShareClass(offering_id.clone(), holder.clone(), sc.clone())).unwrap_or(0);
+                            if holder_share > 0 {
+                                let class_rev = Self::compute_share(env.clone(), amount, config.bps, mode.clone());
+                                let holder_payout = Self::compute_share(env.clone(), class_rev, holder_share, mode.clone());
+                                p = p.saturating_add(holder_payout);
+                            }
+                        }
+                    }
+                    p
+                } else {
+                    Self::compute_share(env.clone(), amount, share_bps, mode.clone())
+                }
             };
             total = total.saturating_add(payout);
             payouts.push_back((holder.clone(), payout));
diff --git a/src/milestone_signals.rs b/src/milestone_signals.rs
index 01f3774..b015901 100644
--- a/src/milestone_signals.rs
+++ b/src/milestone_signals.rs
@@ -51,7 +51,7 @@ fn setup_offering(env: &Env, client: &RevoraRevenueShareClient) -> (Address, Add
     let token = Address::generate(env);
     let payout = Address::generate(env);
     client.set_admin(&issuer);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000u32, &payout, &0i128);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000u32, &payout, &0i128, &None);
     (issuer, token, payout)
 }
 
@@ -469,8 +469,8 @@ fn milestone_audit_summary_isolated_per_offering() {
     let ns = symbol_short!("def");
 
     client.set_admin(&issuer);
-    client.register_offering(&issuer, &ns, &token_a, &1_000u32, &payout, &0i128);
-    client.register_offering(&issuer, &ns, &token_b, &1_000u32, &payout, &0i128);
+    client.register_offering(&issuer, &ns, &token_a, &1_000u32, &payout, &0i128, &None);
+    client.register_offering(&issuer, &ns, &token_b, &1_000u32, &payout, &0i128, &None);
 
     client.report_revenue(&issuer, &ns, &token_a, &payout, &5_000i128, &1u64, &false);
 
diff --git a/src/normalize_share_tests.rs b/src/normalize_share_tests.rs
index 1a22019..92fd8ac 100644
--- a/src/normalize_share_tests.rs
+++ b/src/normalize_share_tests.rs
@@ -20,7 +20,7 @@ fn decimals_bounds_and_default() {
     let token = Address::generate(&env);
     let ns = symbol_short!("def");
 
-    client.register_offering(&issuer, &ns, &token, &0u32, &token, &0i128);
+    client.register_offering(&issuer, &ns, &token, &0u32, &token, &0i128, &None);
 
     assert!(client.try_set_payment_token_decimals(&issuer, &ns, &token, &0u32).is_ok());
     assert_eq!(client.get_payment_token_decimals(&issuer, &ns, &token), 0u32);
diff --git a/src/proptest_helpers.rs b/src/proptest_helpers.rs
index 1f2b064..9333450 100644
--- a/src/proptest_helpers.rs
+++ b/src/proptest_helpers.rs
@@ -17,13 +17,13 @@
 /// ```ignore
 /// proptest! {
 ///     #[test]
-///     fn fuzz_register_offering(bps in arb_valid_bps()) {
+///     fn fuzz_register_offering(bps in arb_valid_bps(), &None) {
 ///         let env = Env::default();
 ///         env.mock_all_auths();
 ///         let client = make_client(&env);
 ///         let issuer = Address::generate(&env);
 ///         let token  = Address::generate(&env);
-///         client.register_offering(&issuer, &symbol_short!("def"), &token, &bps, &token, &0);
+///         client.register_offering(&issuer, &symbol_short!("def"), &token, &bps, &token, &0, &None);
 ///     }
 /// }
 /// ```
@@ -131,7 +131,7 @@ pub fn arb_strictly_increasing_periods(len: usize) -> impl Strategy<Value = Vec<
 /// pre-generated address pool so strategies remain `Send + Sync`.
 #[derive(Debug, Clone)]
 pub enum TestOperation {
-    /// `register_offering(issuer, namespace, token, bps, payout_asset, supply_cap)`
+    /// `register_offering(issuer, namespace, token, bps, payout_asset, supply_cap, &None)`
     RegisterOffering { issuer: Address, namespace: Symbol, token: Address, bps: u32, payout_asset: Address, supply_cap: i128 },
     /// `report_revenue(issuer, namespace, token, payout_asset, amount, period_id, override_existing)`
     ReportRevenue { issuer: Address, namespace: Symbol, token: Address, payout_asset: Address, amount: i128, period_id: u64, override_existing: bool },
@@ -158,7 +158,7 @@ pub enum TestOperation {
 // ── Operation strategies ─────────────────────────────────────────────────────
 
 /// Strategy for a single valid `RegisterOffering` operation.
-pub fn arb_register_offering() -> impl Strategy<Value = TestOperation> {
+pub fn arb_register_offering(, &None) -> impl Strategy<Value = TestOperation> {
     (arb_valid_bps(), 0i128..=1_000_000_000i128)
         .prop_map(|(bps, supply_cap)| TestOperation::RegisterOffering { bps, supply_cap })
 }
@@ -206,7 +206,7 @@ pub fn arb_set_concentration_limit() -> impl Strategy<Value = TestOperation> {
 /// Strategy for any single valid operation (uniform distribution across all variants).
 pub fn any_test_operation() -> impl Strategy<Value = TestOperation> {
     prop_oneof![
-        arb_register_offering(),
+        arb_register_offering(, &None),
         arb_report_revenue(),
         arb_deposit_revenue(),
         arb_set_holder_share(),
diff --git a/src/test.rs b/src/test.rs
index 380a8ad..1e9cb3e 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -629,7 +629,7 @@ fn get_whitelist_empty_before_any_add() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     for period_id in 1..=100_u64 {
         client.report_revenue(
@@ -841,7 +841,7 @@ fn blacklist_overrides_whitelist() {
     let investor = Address::generate(&env);
 
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     // Add to both whitelist and blacklist
     client.whitelist_add(&issuer, &issuer, &symbol_short!("def"), &token, &investor);
@@ -997,7 +997,7 @@ fn register_offering_rejects_bps_over_10000() {
         &10_001,
         &payout_asset,
         &0,
-    );
+    , &None);
     assert!(
         result.is_err(),
         "contract must return Err(RevoraError::InvalidRevenueShareBps) for bps > 10000"
@@ -1021,7 +1021,7 @@ fn register_offering_accepts_bps_exactly_10000() {
         &10_000,
         &payout_asset,
         &0,
-    );
+    , &None);
     assert!(result.is_ok());
 }
 
@@ -1096,7 +1096,7 @@ fn multiple_reports_same_period_accumulate() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     for period_id in 1..=100_u64 {
         client.report_revenue(
@@ -1145,7 +1145,7 @@ fn get_revenue_range_sums_periods() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &payout_asset, &0, &None);
     client.report_revenue(&issuer, &symbol_short!("def"), &token, &payout_asset, &100, &1, &false);
     client.report_revenue(&issuer, &symbol_short!("def"), &token, &payout_asset, &200, &2, &false);
     assert_eq!(client.get_revenue_range(&issuer, &symbol_short!("def"), &token, &1, &2), 300);
@@ -1170,7 +1170,7 @@ fn gas_characterization_report_revenue_with_large_blacklist() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &500, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &500, &payout_asset, &0, &None);
 
     for _ in 0..30 {
         client.blacklist_add(
@@ -1221,7 +1221,7 @@ fn large_period_range_sums_correctly() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     client.report_revenue(&issuer, &symbol_short!("def"), &token, &token, &1_000, &1, &false);
 }
 
@@ -1237,7 +1237,7 @@ fn concentration_limit_not_set_allows_report_revenue() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.report_revenue(
         &issuer,
         &symbol_short!("def"),
@@ -1270,7 +1270,7 @@ fn set_concentration_limit_stores_config() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &false, &0u64);
     let config = client.get_concentration_limit(&issuer, &symbol_short!("def"), &token);
     assert_eq!(config.clone().unwrap().max_bps, 5000);
@@ -1288,7 +1288,7 @@ fn set_concentration_limit_bounds_check() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     let res =
         client.try_set_concentration_limit(&issuer, &symbol_short!("def"), &token, &10001, &false, &0u64);
@@ -1303,7 +1303,7 @@ fn report_concentration_bounds_check() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     let res = client.try_report_concentration(&issuer, &symbol_short!("def"), &token, &10001);
     assert!(res.is_err());
@@ -1320,7 +1320,7 @@ fn set_concentration_limit_respects_pause() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
     client.initialize(&admin, &None, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     client.pause_admin(&admin);
     let res =
@@ -1339,7 +1339,7 @@ fn report_concentration_respects_pause() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
     client.initialize(&admin, &None, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     client.pause_admin(&admin);
     let res = client.try_report_concentration(&issuer, &symbol_short!("def"), &token, &5000);
@@ -1355,7 +1355,7 @@ fn report_concentration_emits_audit_event() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     let before = env.events().all().len();
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &3000);
@@ -1372,7 +1372,7 @@ fn report_concentration_emits_warning_when_over_limit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &false, &0u64);
     let before = env.events().all().len();
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &6000);
@@ -1391,7 +1391,7 @@ fn report_concentration_no_warning_when_below_limit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &false, &0u64);
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &4000);
     assert_eq!(
@@ -1408,7 +1408,7 @@ fn concentration_enforce_blocks_report_revenue_when_over_limit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &0u64);
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &6000);
     let r = client.try_report_revenue(
@@ -1434,7 +1434,7 @@ fn concentration_enforce_allows_report_revenue_when_at_or_below_limit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &0u64);
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &5000);
     client.report_revenue(
@@ -1466,7 +1466,7 @@ fn concentration_near_threshold_boundary() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &0u64);
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &5001);
 
@@ -1507,7 +1507,7 @@ fn set_concentration_limit_requires_auth_before_state_read() {
 
     // Register the offering with mocked auth so it exists in storage.
     env.mock_all_auths();
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     // Now clear mocked auths — subsequent calls require real auth.
     let env2 = Env::default();
@@ -1541,7 +1541,7 @@ fn set_concentration_limit_auth_required_even_in_event_only_mode() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     // With mock_all_auths the call succeeds (auth is satisfied).
     let result = client.try_set_concentration_limit(
@@ -1570,7 +1570,7 @@ fn set_concentration_limit_wrong_issuer_rejected_after_auth() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     // attacker tries to set the limit on issuer's offering.
     let result = client.try_set_concentration_limit(
@@ -1598,7 +1598,7 @@ fn concentration_staleness_no_prior_report_rejected() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     // enforce=true, max_staleness_secs=3600 — no report_concentration called yet
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &3600u64);
     let r = client.try_report_revenue(
@@ -1627,7 +1627,7 @@ fn concentration_staleness_stale_report_rejected() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &3600u64);
 
     // Report concentration at t=1000
@@ -1662,7 +1662,7 @@ fn concentration_staleness_fresh_report_allowed() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &3600u64);
 
     // Report concentration at t=1000
@@ -1692,7 +1692,7 @@ fn concentration_staleness_enforce_off_bypasses_guard() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     // enforce=false — staleness guard must not fire
     client.set_concentration_limit(
         &issuer,
@@ -1724,7 +1724,7 @@ fn concentration_staleness_zero_secs_disables_guard() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     // max_staleness_secs=0 — guard disabled
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &0u64);
     // No report_concentration called — should not be rejected for staleness
@@ -1749,7 +1749,7 @@ fn concentration_staleness_boundary_exact_window_allowed() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &3600u64);
 
     env.ledger().set_timestamp(1000);
@@ -1800,7 +1800,7 @@ fn set_rounding_mode_wrong_issuer_rejected_after_auth() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     let result = client.try_set_rounding_mode(
         &attacker,
@@ -1823,7 +1823,7 @@ fn audit_summary_empty_before_any_report() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     let summary = client.get_audit_summary(&issuer, &symbol_short!("def"), &token);
     assert!(summary.is_none());
 }
@@ -1836,7 +1836,7 @@ fn audit_summary_aggregates_revenue_and_count() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.report_revenue(&issuer, &symbol_short!("def"), &token, &payout_asset, &100, &1, &false);
     client.report_revenue(&issuer, &symbol_short!("def"), &token, &payout_asset, &200, &2, &false);
     client.report_revenue(&issuer, &symbol_short!("def"), &token, &payout_asset, &300, &3, &false);
@@ -1858,8 +1858,8 @@ fn audit_summary_per_offering_isolation() {
     let token_b = Address::generate(&env);
     let payout_asset_a = Address::generate(&env);
     let payout_asset_b = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &1_000, &payout_asset_a, &0);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &1_000, &payout_asset_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &1_000, &payout_asset_a, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &1_000, &payout_asset_b, &0, &None);
     client.report_revenue(
         &issuer,
         &symbol_short!("def"),
@@ -1942,14 +1942,14 @@ fn set_and_get_rounding_mode() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     assert_eq!(
         client.get_rounding_mode(&issuer, &symbol_short!("def"), &token),
         RoundingMode::Truncation
     );
 
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     assert_eq!(
         client.get_rounding_mode(&issuer, &symbol_short!("def"), &token),
         RoundingMode::Truncation
@@ -2093,7 +2093,7 @@ fn claim_setup() -> (Env, RevoraRevenueShareClient<'static>, Address, Address, A
     let (payment_token, pt_admin) = create_payment_token(&env);
 
     // Register offering
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0); // 50% revenue share
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None); // 50% revenue share
 
     // Mint payment tokens to the issuer so they can deposit
     mint_tokens(&env, &payment_token, &pt_admin, &issuer, &10_000_000);
@@ -2130,7 +2130,7 @@ fn register_offering_does_not_lock_payment_token_before_first_deposit() {
         &5_000,
         &payout_asset,
         &0,
-    );
+    , &None);
 
     assert_eq!(client.get_payment_token(&issuer, &symbol_short!("def"), &offering_token), None);
 }
@@ -2162,7 +2162,7 @@ fn failed_invalid_first_deposit_does_not_lock_payment_token() {
         &5_000,
         &payment_token,
         &0,
-    );
+    , &None);
 
     let result = client.try_deposit_revenue(
         &issuer,
@@ -2242,7 +2242,7 @@ fn report_revenue_rejects_mismatched_payout_asset() {
     let payout_asset = Address::generate(&env);
     let wrong_asset = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     let r = client.try_report_revenue(
         &issuer,
         &symbol_short!("def"),
@@ -2272,7 +2272,7 @@ fn first_deposit_uses_registered_payment_token_lock() {
         &5_000,
         &configured_asset,
         &0,
-    );
+    , &None);
     mint_tokens(&env, &configured_asset, &configured_admin, &issuer, &1_000_000);
 
     client.deposit_revenue(
@@ -2307,7 +2307,7 @@ fn failed_first_deposit_does_not_lock_payment_token_or_consume_period() {
         &5_000,
         &payment_token,
         &0,
-    );
+    , &None);
 
     let failed = client.try_deposit_revenue(
         &issuer,
@@ -2402,7 +2402,7 @@ fn deposit_revenue_rejects_mismatched_token_after_lock() {
     let (locked_token, locked_admin) = create_payment_token(&env);
     let (other_token, other_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &locked_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &locked_token, &0, &None);
     mint_tokens(&env, &locked_token, &locked_admin, &issuer, &1_000_000);
     mint_tokens(&env, &other_token, &other_admin, &issuer, &1_000_000);
 
@@ -2440,7 +2440,7 @@ fn deposit_revenue_rejects_wrong_token_on_first_deposit() {
         &5_000,
         &configured_token,
         &0,
-    );
+    , &None);
     mint_tokens(&env, &wrong_token, &wrong_admin, &issuer, &1_000_000);
 
     // First deposit with wrong token must be rejected
@@ -2484,8 +2484,8 @@ fn payment_token_lock_is_per_offering() {
     let (asset_a, admin_a) = create_payment_token(&env);
     let (asset_b, admin_b) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &5_000, &asset_a, &0);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &5_000, &asset_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &5_000, &asset_a, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &5_000, &asset_b, &0, &None);
 
     mint_tokens(&env, &asset_a, &admin_a, &issuer, &1_000_000);
     mint_tokens(&env, &asset_b, &admin_b, &issuer, &1_000_000);
@@ -2522,7 +2522,7 @@ fn payment_token_none_before_first_deposit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let (payout, _) = create_payment_token(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
     assert_eq!(client.get_payment_token(&issuer, &symbol_short!("def"), &token), None);
 }
 
@@ -2536,7 +2536,7 @@ fn payment_token_locked_after_first_successful_deposit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let (payout, admin) = create_payment_token(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
     mint_tokens(&env, &payout, &admin, &issuer, &1_000_000);
     client.deposit_revenue(&issuer, &symbol_short!("def"), &token, &payout, &100_000, &1);
     assert_eq!(
@@ -2556,7 +2556,7 @@ fn payment_token_mismatch_returns_correct_error_code() {
     let token = Address::generate(&env);
     let (payout_a, admin_a) = create_payment_token(&env);
     let (payout_b, admin_b) = create_payment_token(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_a, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_a, &0, &None);
     mint_tokens(&env, &payout_a, &admin_a, &issuer, &1_000_000);
     mint_tokens(&env, &payout_b, &admin_b, &issuer, &1_000_000);
 
@@ -2589,7 +2589,7 @@ fn payment_token_not_locked_after_failed_first_deposit() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let (payout, admin) = create_payment_token(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
     // No mint — transfer will fail
     let r = client.try_deposit_revenue(
         &issuer,
@@ -2680,8 +2680,8 @@ fn multi_offering_different_payment_tokens_independent() {
     let (payment_token_y, admin_y) = create_payment_token(&env);
 
     // Register two offerings in same namespace ("multi") but different tokens
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &payment_token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &payment_token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &payment_token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &payment_token_y, &0, &None);
 
     // Mint tokens for issuer
     mint_tokens(&env, &payment_token_x, &admin_x, &issuer, &1_000_000);
@@ -2726,8 +2726,8 @@ fn multi_offering_cross_deposit_fails_with_payment_token_mismatch() {
     let (token_y, admin_y) = create_payment_token(&env);
     let (token_z, admin_z) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &1_000_000);
     mint_tokens(&env, &token_y, &admin_y, &issuer, &1_000_000);
@@ -2781,8 +2781,8 @@ fn multi_offering_cross_deposit_does_not_mutate_state() {
     let (token_y, admin_y) = create_payment_token(&env);
     let (token_z, admin_z) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &1_000_000);
     mint_tokens(&env, &token_y, &admin_y, &issuer, &1_000_000);
@@ -2829,8 +2829,8 @@ fn multi_offering_independent_deposits_then_cross_fail() {
     let (token_y, admin_y) = create_payment_token(&env);
     let (token_z, admin_z) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &1_000_000);
     mint_tokens(&env, &token_y, &admin_y, &issuer, &1_000_000);
@@ -2877,8 +2877,8 @@ fn multi_offering_same_payment_token_both_offerings() {
     let (payment_token, admin) = create_payment_token(&env);
 
     // Both offerings use the SAME payment token
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &payment_token, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &payment_token, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &payment_token, &0, &None);
 
     mint_tokens(&env, &payment_token, &admin, &issuer, &2_000_000);
 
@@ -2915,8 +2915,8 @@ fn multi_offering_independent_period_sequencing() {
     let (token_x, admin_x) = create_payment_token(&env);
     let (token_y, admin_y) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &5_000_000);
     mint_tokens(&env, &token_y, &admin_y, &issuer, &5_000_000);
@@ -2958,8 +2958,8 @@ fn multi_offering_snapshot_deposits_independent() {
     let (token_x, admin_x) = create_payment_token(&env);
     let (token_y, admin_y) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
 
     // Enable snapshot for both
     client.set_snapshot_config(&issuer, &symbol_short!("multi"), &token_a, &true);
@@ -3014,7 +3014,7 @@ fn multi_offering_snapshot_locks_payment_token() {
     let (token_x, admin_x) = create_payment_token(&env);
     let (token_z, admin_z) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
     client.set_snapshot_config(&issuer, &symbol_short!("multi"), &token_a, &true);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &1_000_000);
@@ -3060,9 +3060,9 @@ fn multi_offering_three_offerings_full_isolation() {
     let (token_z, admin_z) = create_payment_token(&env);
 
     // Register three offerings
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_c, &5_000, &token_z, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_c, &5_000, &token_z, &0, &None);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &1_000_000);
     mint_tokens(&env, &token_y, &admin_y, &issuer, &1_000_000);
@@ -3117,8 +3117,8 @@ fn multi_offering_interleaved_deposits_maintain_isolation() {
     let (token_x, admin_x) = create_payment_token(&env);
     let (token_y, admin_y) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0);
-    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_a, &5_000, &token_x, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("multi"), &token_b, &5_000, &token_y, &0, &None);
 
     mint_tokens(&env, &token_x, &admin_x, &issuer, &5_000_000);
     mint_tokens(&env, &token_y, &admin_y, &issuer, &5_000_000);
@@ -3157,7 +3157,7 @@ fn get_payment_token_decimals_defaults_to_7() {
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
 
     assert_eq!(client.get_payment_token_decimals(&issuer, &symbol_short!("def"), &token), 7);
 }
@@ -3172,7 +3172,7 @@ fn set_and_get_payment_token_decimals() {
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
     client.set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &6);
 
     assert_eq!(client.get_payment_token_decimals(&issuer, &symbol_short!("def"), &token), 6);
@@ -3188,7 +3188,7 @@ fn set_payment_token_decimals_rejects_out_of_range() {
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
 
     let result = client.try_set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &19);
     assert!(result.is_err());
@@ -3204,7 +3204,7 @@ fn set_payment_token_decimals_accepts_max_18() {
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
 
     let result = client.try_set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &18);
     assert!(result.is_ok());
@@ -3221,7 +3221,7 @@ fn set_payment_token_decimals_accepts_zero() {
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout, &0, &None);
 
     let result = client.try_set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &0);
     assert!(result.is_ok());
@@ -3242,7 +3242,7 @@ fn claim_normalizes_6_decimal_token_revenue() {
     let holder = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     // Configure 6-decimal token (e.g., USDC)
     client.set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &6);
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &5_000); // 50%
@@ -3275,7 +3275,7 @@ fn claim_normalizes_8_decimal_token_revenue() {
     let holder = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     // Configure 8-decimal token (e.g., WBTC)
     client.set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &8);
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &5_000); // 50%
@@ -3309,7 +3309,7 @@ fn claim_with_7_decimal_token_is_unchanged() {
     let holder = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     // Default is 7 decimals — no explicit set needed
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &5_000); // 50%
 
@@ -3334,7 +3334,7 @@ fn get_claimable_normalizes_6_decimal_token() {
     let holder = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     client.set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &6);
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &5_000);
 
@@ -3414,7 +3414,7 @@ fn deposit_revenue_exactly_at_supply_cap_succeeds() {
     let token = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     mint_tokens(&env, &payment_token, &pt_admin, &issuer, &10_000_000);
 
     // exactly at cap should succeed
@@ -3432,7 +3432,7 @@ fn deposit_revenue_exceeds_supply_cap_fails() {
     let token = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     mint_tokens(&env, &payment_token, &pt_admin, &issuer, &10_000_000);
 
     // Deposit exceeds cap should fail
@@ -3450,7 +3450,7 @@ fn deposit_revenue_multiple_deposits_exceeds_supply_cap_fails() {
     let token = Address::generate(&env);
     let (payment_token, pt_admin) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     mint_tokens(&env, &payment_token, &pt_admin, &issuer, &10_000_000);
 
     client.deposit_revenue(&issuer, &symbol_short!("def"), &token, &payment_token, &50_000, &1);
@@ -3468,7 +3468,7 @@ fn set_investment_constraints_succeeds_for_valid_bounds() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     client.set_investment_constraints(&issuer, &symbol_short!("def"), &token, &100, &1_000);
     
     let constraints = client.get_investment_constraints(&issuer, &symbol_short!("def"), &token).unwrap();
@@ -3486,7 +3486,7 @@ fn set_investment_constraints_fails_when_max_less_than_min() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     let r = client.try_set_investment_constraints(&issuer, &symbol_short!("def"), &token, &1_000, &100);
     assert!(r.is_err());
 }
@@ -3501,7 +3501,7 @@ fn set_investment_constraints_fails_negative() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     let r = client.try_set_investment_constraints(&issuer, &symbol_short!("def"), &token, &-1, &100);
     assert!(r.is_err());
     
@@ -3519,7 +3519,7 @@ fn set_investment_constraints_emits_event() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &100_000, &None);
     
     let before = legacy_events(&env).len();
     client.set_investment_constraints(&issuer, &symbol_short!("def"), &token, &100, &1_000);
@@ -3547,7 +3547,7 @@ fn register_capped_offering(
     payment_token: &Address,
     cap: i128,
 ) {
-    client.register_offering(issuer, &symbol_short!("cap"), token, &5_000, payment_token, &cap);
+    client.register_offering(issuer, &symbol_short!("cap"), token, &5_000, payment_token, &cap, &None);
 }
 
 #[test]
@@ -3560,7 +3560,7 @@ fn get_deposited_revenue_returns_zero_before_any_deposit() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("cap"), &token, &5_000, &payment_token, &100_000);
+    client.register_offering(&issuer, &symbol_short!("cap"), &token, &5_000, &payment_token, &100_000, &None);
 
     // No deposits yet — read API must return 0.
     assert_eq!(client.get_deposited_revenue(&issuer, &symbol_short!("cap"), &token), 0);
@@ -3598,7 +3598,7 @@ fn deposit_revenue_no_cap_is_unlimited() {
     let (payment_token, pt_admin) = create_payment_token(&env);
 
     // Register with cap = 0 (unlimited).
-    client.register_offering(&issuer, &symbol_short!("cap"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("cap"), &token, &5_000, &payment_token, &0, &None);
     mint_tokens(&env, &payment_token, &pt_admin, &issuer, &10_000_000_000);
 
     let r = client.try_deposit_revenue(
@@ -3811,7 +3811,7 @@ fn get_supply_cap_returns_zero_when_no_cap_set() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("cap"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("cap"), &token, &5_000, &payment_token, &0, &None);
     assert_eq!(client.get_supply_cap(&issuer, &symbol_short!("cap"), &token), 0);
 }
 
@@ -3871,7 +3871,7 @@ fn get_investment_constraints_returns_none_before_set() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     // Read API must return None before constraints are configured.
     assert!(
         client.get_investment_constraints(&issuer, &symbol_short!("def"), &token).is_none(),
@@ -3890,7 +3890,7 @@ fn set_investment_constraints_both_zero_succeeds() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     let r = client.try_set_investment_constraints(
         &issuer, &symbol_short!("def"), &token, &0, &0,
     );
@@ -3912,7 +3912,7 @@ fn set_investment_constraints_equal_min_and_max_succeeds() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     let r = client.try_set_investment_constraints(
         &issuer, &symbol_short!("def"), &token, &1_000, &1_000,
     );
@@ -3934,7 +3934,7 @@ fn set_investment_constraints_min_zero_max_positive_succeeds() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     let r = client.try_set_investment_constraints(
         &issuer, &symbol_short!("def"), &token, &0, &5_000,
     );
@@ -3956,7 +3956,7 @@ fn set_investment_constraints_updates_replace_previous() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     client.set_investment_constraints(&issuer, &symbol_short!("def"), &token, &100, &1_000);
     client.set_investment_constraints(&issuer, &symbol_short!("def"), &token, &200, &2_000);
 
@@ -3977,7 +3977,7 @@ fn set_investment_constraints_update_event_marks_previous_existed() {
     let token = Address::generate(&env);
     let (payment_token, _) = create_payment_token(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
     // First call — no previous, event payload should have is_update = false.
     client.set_investment_constraints(&issuer, &symbol_short!("def"), &token, &100, &1_000);
 
@@ -4919,7 +4919,7 @@ fn offering_isolation_claims_independent() {
     // Register a second offering
     let token_b = Address::generate(&env);
     let (pt_b, pt_b_admin) = create_payment_token(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &3_000, &pt_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &3_000, &pt_b, &0, &None);
 
     // Create a second payment token for offering B
     mint_tokens(&env, &pt_b, &pt_b_admin, &issuer, &5_000_000);
@@ -5350,7 +5350,7 @@ fn freeze_sets_flag_and_emits_event() {
 }
 
 #[test]
-fn frozen_blocks_register_offering() {
+fn frozen_blocks_register_offering(, &None) {
     let (env, client, issuer, _token, _payment_token, _contract_id) = claim_setup();
     let admin = Address::generate(&env);
     let issuer = admin.clone();
@@ -5367,7 +5367,7 @@ fn frozen_blocks_register_offering() {
         &1_000,
         &payout_asset,
         &0,
-    );
+    , &None);
     assert!(r.is_err());
 }
 
@@ -5449,7 +5449,7 @@ fn freeze_offering_sets_flag_and_emits_event() {
 fn freeze_offering_blocks_only_target_offering() {
     let (env, client, issuer, token_a, payment_token, _contract_id) = claim_setup();
     let token_b = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &5_000, &payment_token, &0, &None);
 
     let holder = Address::generate(&env);
     client.freeze_offering(&issuer, &issuer, &symbol_short!("def"), &token_a);
@@ -5912,7 +5912,7 @@ fn testnet_mode_allows_bps_over_10000() {
         &15_000,
         &payout_asset,
         &0,
-    );
+    , &None);
     assert!(result.is_ok());
 
     // Verify offering was registered
@@ -5937,7 +5937,7 @@ fn testnet_mode_disabled_rejects_bps_over_10000() {
         &15_000,
         &payout_asset,
         &0,
-    );
+    , &None);
     assert!(result.is_err());
 }
 
@@ -5957,7 +5957,7 @@ fn testnet_mode_skips_concentration_enforcement() {
     client.set_testnet_mode(&true);
 
     // Register offering and set concentration limit with enforcement
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &0u64);
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &8000); // Over limit
 
@@ -6058,7 +6058,7 @@ fn testnet_mode_disabled_enforces_concentration() {
     let payout_asset = Address::generate(&env);
 
     // Testnet mode disabled (default)
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &true, &0u64);
     client.report_concentration(&issuer, &symbol_short!("def"), &token, &8000); // Over limit
 
@@ -6089,7 +6089,7 @@ fn testnet_mode_toggle_after_offerings_exist() {
     let payout_asset2 = Address::generate(&env);
 
     // Register offering in normal mode
-    client.register_offering(&issuer, &symbol_short!("def"), &token1, &5_000, &payout_asset1, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token1, &5_000, &payout_asset1, &0, &None);
 
     // Set admin and enable testnet mode
     client.set_admin(&admin);
@@ -6103,7 +6103,7 @@ fn testnet_mode_toggle_after_offerings_exist() {
         &20_000,
         &payout_asset2,
         &0,
-    );
+    , &None);
     assert!(result.is_ok());
 
     // Verify both offerings exist
@@ -6126,7 +6126,7 @@ fn testnet_mode_affects_only_validation_not_storage() {
     client.set_testnet_mode(&true);
 
     // Register with high bps
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &25_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &25_000, &payout_asset, &0, &None);
 
     // Disable testnet mode
     client.set_testnet_mode(&false);
@@ -6152,7 +6152,7 @@ fn testnet_mode_multiple_offerings_with_varied_bps() {
         let token = Address::generate(&env);
         let bps = 10_000 + (i * 1_000);
         let payout_asset = Address::generate(&env);
-        client.register_offering(&issuer, &symbol_short!("def"), &token, &bps, &payout_asset, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &token, &bps, &payout_asset, &0, &None);
     }
 
     assert_eq!(client.get_offering_count(&issuer, &symbol_short!("def")), 5);
@@ -6172,7 +6172,7 @@ fn testnet_mode_concentration_warning_still_emitted() {
     client.set_admin(&admin);
     client.set_testnet_mode(&true);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.set_concentration_limit(&issuer, &symbol_short!("def"), &token, &5000, &false, &0u64);
 
     // Warning should still be emitted in testnet mode
@@ -6609,7 +6609,7 @@ fn issuer_transfer_multiple_offerings_isolation() {
     let new_issuer_b = Address::generate(&env);
 
     // Register second offering
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &3_000, &token_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &3_000, &token_b, &0, &None);
 
     // Propose transfers for both (same issuer for both offerings)
     client.propose_issuer_transfer(&issuer, &symbol_short!("def"), &token_a, &new_issuer_a);
@@ -7883,7 +7883,7 @@ fn issuer_transfer_wrong_address_cannot_accept() {
     let token2 = Address::generate(&env2);
     let payout2 = Address::generate(&env2);
     let new_issuer2 = Address::generate(&env2);
-    client2.register_offering(&issuer2, &symbol_short!("def"), &token2, &1_000, &payout2, &0);
+    client2.register_offering(&issuer2, &symbol_short!("def"), &token2, &1_000, &payout2, &0, &None);
     client2.propose_issuer_transfer(&issuer2, &symbol_short!("def"), &token2, &new_issuer2);
 
     // Pending transfer is to new_issuer2; verify it is stored correctly
@@ -8158,7 +8158,7 @@ fn testnet_mode_normal_operations_unaffected() {
     client.set_testnet_mode(&true);
 
     // Normal operations should work as expected
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
     client.report_revenue(
         &issuer,
         &symbol_short!("def"),
@@ -8224,7 +8224,7 @@ fn testnet_mode_pagination_unaffected() {
             &(1_000 + i * 100),
             &payout_asset,
             &0,
-        );
+        , &None);
     }
 
     // Pagination should work normally
@@ -8291,7 +8291,7 @@ fn register_blocked_while_paused() {
     client.initialize(&admin, &None::<Address>, &None::<bool>);
     client.pause_admin(&admin);
     assert!(client
-        .try_register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0)
+        .try_register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None)
         .is_err());
 }
 
@@ -8306,7 +8306,7 @@ fn report_blocked_while_paused() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.pause_admin(&admin);
     assert!(client
         .try_report_revenue(
@@ -8358,7 +8358,7 @@ fn blacklist_add_blocked_while_paused() {
     let investor = Address::generate(&env);
 
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.pause_admin(&admin);
     assert!(client
         .try_blacklist_add(&admin, &issuer, &symbol_short!("def"), &token, &investor)
@@ -8379,7 +8379,7 @@ fn blacklist_remove_blocked_while_paused() {
     let investor = Address::generate(&env);
 
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     client.pause_admin(&admin);
     assert!(client
         .try_blacklist_remove(&admin, &issuer, &symbol_short!("def"), &token, &investor)
@@ -8393,7 +8393,7 @@ fn large_period_range_sums_correctly_full() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &payout_asset, &0, &None);
     for period in 1..=10 {
         client.report_revenue(
             &issuer,
@@ -8457,7 +8457,7 @@ fn check_invariants_enhanced(env: &Env, client: &RevoraRevenueShareClient, issue
             if client.is_paused() {
                 // Mutations should be blocked; verify by attempting a mutation
                 let dummy_token = Address::generate(env);
-                let result = client.try_register_offering(&issuer, &ns, &dummy_token, &1000, &dummy_token, &0);
+                let result = client.try_register_offering(&issuer, &ns, &dummy_token, &1000, &dummy_token, &0, &None);
                 assert!(result.is_err(), "Mutations allowed when paused");
             }
 
@@ -8493,7 +8493,7 @@ proptest! {
         for op in seq {
             match op {
                 TestOperation::RegisterOffering((i, ns, t, bps, pa)) => {
-                    client.register_offering(&i, &ns, &t, &bps, &pa, &0);
+                    client.register_offering(&i, &ns, &t, &bps, &pa, &0, &None);
                 }
                 TestOperation::ReportRevenue((i, ns, t, pa, amt, pid, ovr)) => {
                     client.report_revenue(&i, &ns, &t, &pa, &amt, &pid, &ovr);
@@ -8523,7 +8523,7 @@ proptest! {
         let ns = symbol_short!("def");
         let token = Address::generate(&env);
 
-        client.register_offering(&issuer, &ns, &token, &1000, &token.clone(), &0);
+        client.register_offering(&issuer, &ns, &token, &1000, &token.clone(), &0, &None);
         
         // Execute background sequence
         for op in seq {
@@ -8602,7 +8602,7 @@ proptest! {
         let token = Address::generate(&env);
         // Mutations panic post-pause
         let result = std::panic::catch_unwind(|| {
-            client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token.clone(), &0);
+            client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token.clone(), &0, &None);
         });
         prop_assert!(result.is_err());
     }
@@ -8623,7 +8623,7 @@ proptest! {
     ) {
         let (i, ns, t) = offering;
         let client = make_client(&env);
-        client.register_offering(&i, &ns, &t, &1000, &t.clone(), &0);
+        client.register_offering(&i, &ns, &t, &1000, &t.clone(), &0, &None);
 
         // Blacklist holder
         client.blacklist_add(&i, &i, &ns, &t.clone(), &holder);
@@ -8651,7 +8651,7 @@ proptest! {
         // Register exactly N offerings
         for _ in 0..n {
             let token = Address::generate(&env);
-            client.register_offering(&issuer, &ns, &token, &1000, &token, &0);
+            client.register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
         }
 
         assert_eq!(client.get_offering_count(&issuer, &ns), n as u32);
@@ -8723,7 +8723,7 @@ fn test_offerings_pagination_stress() {
     
     for _ in 0..num_offerings {
         let token = Address::generate(&env);
-        client.register_offering(&issuer, &ns, &token, &1000, &token, &0);
+        client.register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
     }
 
     // 1. Verify MAX_PAGE_LIMIT enforcement
@@ -8760,7 +8760,7 @@ fn test_blacklist_pagination_stress() {
     let ns = symbol_short!("def");
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &ns, &token, &1000, &token, &0);
+    client.register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
 
     let num_blacklisted = 45;
     for _ in 0..num_blacklisted {
@@ -8797,7 +8797,7 @@ fn test_whitelist_pagination_stress() {
     let ns = symbol_short!("def");
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &ns, &token, &1000, &token, &0);
+    client.register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
 
     let num_whitelisted = 45;
     for _ in 0..num_whitelisted {
@@ -8866,7 +8866,7 @@ fn calculate_distribution_bps_100_percent() {
 
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &10_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &10_000, &token, &0, &None);
 
     let payout = client.calculate_distribution(
         &caller,
@@ -8894,7 +8894,7 @@ fn calculate_distribution_bps_25_percent() {
 
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &2_500, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &2_500, &token, &0, &None);
 
     let payout = client.calculate_distribution(
         &caller,
@@ -9032,7 +9032,7 @@ fn calculate_distribution_rounds_down() {
 
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &3_333, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &3_333, &token, &0, &None);
 
     let payout = client.calculate_distribution(
         &caller,
@@ -9058,7 +9058,7 @@ fn calculate_distribution_rounds_down_exact() {
     let caller = Address::generate(&env);
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &2_500, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &2_500, &token, &0, &None);
 
     let payout = client.calculate_distribution(
         &caller,
@@ -9130,7 +9130,7 @@ fn calculate_distribution_multiple_holders_sum() {
     let caller = Address::generate(&env);
     let issuer = caller.clone();
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &token, &0, &None);
 
     let holder_a = Address::generate(&env);
     let holder_b = Address::generate(&env);
@@ -9188,7 +9188,7 @@ fn calculate_distribution_requires_auth() {
 
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &token, &0, &None);
 
     client.calculate_distribution(
         &caller,
@@ -9220,7 +9220,7 @@ fn calculate_total_distributable_bps_100_percent() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &10_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &10_000, &token, &0, &None);
 
     let total =
         client.calculate_total_distributable(&issuer, &symbol_short!("def"), &token, &100_000);
@@ -9236,7 +9236,7 @@ fn calculate_total_distributable_bps_25_percent() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &2_500, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &2_500, &token, &0, &None);
 
     let total =
         client.calculate_total_distributable(&issuer, &symbol_short!("def"), &token, &100_000);
@@ -9261,7 +9261,7 @@ fn calculate_total_distributable_rounds_down() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &3_333, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &3_333, &token, &0, &None);
 
     let total = client.calculate_total_distributable(&issuer, &symbol_short!("def"), &token, &100);
 
@@ -9302,7 +9302,7 @@ fn calculate_distribution_offering_isolation() {
 
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &8_000, &token_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &8_000, &token_b, &0, &None);
 
     let payout_a = client.calculate_distribution(
         &caller,
@@ -9334,7 +9334,7 @@ fn calculate_total_distributable_offering_isolation() {
     let (env, client, issuer, token, _payment_token, _contract_id) = claim_setup();
     let token_b = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &8_000, &token_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &8_000, &token_b, &0, &None);
 
     let total_a =
         client.calculate_total_distributable(&issuer, &symbol_short!("def"), &token, &100_000);
@@ -9435,7 +9435,7 @@ fn test_event_only_mode_register_and_report() {
     assert!(client.is_event_only());
 
     // Register offering should emit event but NOT persist state
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &payout_asset, &0, &None);
 
     // Verify event emitted (skip checking EVENT_INIT)
     let events = legacy_events(&env);
@@ -9526,7 +9526,7 @@ fn test_set_offering_metadata_success() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "ipfs://QmTest123");
     let result =
@@ -9542,7 +9542,7 @@ fn test_get_offering_metadata_returns_none_initially() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = client.get_offering_metadata(&issuer, &symbol_short!("def"), &token);
     assert_eq!(metadata, None);
@@ -9556,7 +9556,7 @@ fn test_update_offering_metadata_success() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata1 = SdkString::from_str(&env, "ipfs://QmFirst");
     client.set_offering_metadata(&issuer, &symbol_short!("def"), &token, &metadata1);
@@ -9575,7 +9575,7 @@ fn test_get_offering_metadata_after_set() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "https://example.com/metadata.json");
     let r = client.try_set_offering_metadata(&issuer, &symbol_short!("def"), &token, &metadata);
@@ -9593,7 +9593,7 @@ fn test_set_metadata_requires_auth() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "ipfs://QmTest");
     client.set_offering_metadata(&issuer, &symbol_short!("def"), &token, &metadata);
@@ -9625,7 +9625,7 @@ fn test_set_metadata_respects_freeze() {
     let token = Address::generate(&env);
 
     client.initialize(&admin, &None, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
     client.freeze();
 
     let metadata = SdkString::from_str(&env, "ipfs://QmTest");
@@ -9646,7 +9646,7 @@ fn test_set_metadata_respects_pause() {
     let token = Address::generate(&env);
 
     client.initialize(&admin, &None, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
     client.pause_admin(&admin);
 
     let metadata = SdkString::from_str(&env, "ipfs://QmTest");
@@ -9663,7 +9663,7 @@ fn test_set_metadata_empty_string() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "");
     let result =
@@ -9682,7 +9682,7 @@ fn test_set_metadata_max_length() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     // Create a 256-byte string (max allowed)
     let max_str = "a".repeat(256);
@@ -9700,7 +9700,7 @@ fn test_set_metadata_oversized_data() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     // Create a 257-byte string (exceeds max)
     let oversized_str = "a".repeat(257);
@@ -9718,7 +9718,7 @@ fn test_set_metadata_repeated_updates() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata_values =
         ["ipfs://QmTest0", "ipfs://QmTest1", "ipfs://QmTest2", "ipfs://QmTest3", "ipfs://QmTest4"];
@@ -9743,8 +9743,8 @@ fn test_metadata_scoped_per_offering() {
     let token_a = Address::generate(&env);
     let token_b = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &1000, &token_a, &0);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &2000, &token_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &1000, &token_a, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &2000, &token_b, &0, &None);
 
     let metadata_a = SdkString::from_str(&env, "ipfs://QmTokenA");
     let metadata_b = SdkString::from_str(&env, "ipfs://QmTokenB");
@@ -9768,7 +9768,7 @@ fn test_metadata_set_emits_event() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let before = legacy_events(&env).len();
     let metadata = SdkString::from_str(&env, "ipfs://QmTest");
@@ -9794,7 +9794,7 @@ fn test_metadata_update_emits_event() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata1 = SdkString::from_str(&env, "ipfs://QmFirst");
     client.set_offering_metadata(&issuer, &symbol_short!("def"), &token, &metadata1);
@@ -9823,7 +9823,7 @@ fn test_metadata_events_include_correct_data() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "ipfs://QmTest123");
     client.set_offering_metadata(&issuer, &symbol_short!("def"), &token, &metadata);
@@ -9857,9 +9857,9 @@ fn test_metadata_multiple_offerings_same_issuer() {
     let token2 = Address::generate(&env);
     let token3 = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token1, &1000, &token1, &0);
-    client.register_offering(&issuer, &symbol_short!("def"), &token2, &2000, &token2, &0);
-    client.register_offering(&issuer, &symbol_short!("def"), &token3, &3000, &token3, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token1, &1000, &token1, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("def"), &token2, &2000, &token2, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("def"), &token3, &3000, &token3, &0, &None);
 
     let meta1 = SdkString::from_str(&env, "ipfs://Qm1");
     let meta2 = SdkString::from_str(&env, "ipfs://Qm2");
@@ -9883,7 +9883,7 @@ fn test_metadata_after_issuer_transfer() {
     let new_issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&old_issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&old_issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "ipfs://QmOriginal");
     client.set_offering_metadata(&old_issuer, &symbol_short!("def"), &token, &metadata);
@@ -9912,7 +9912,7 @@ fn test_set_metadata_requires_issuer() {
     let non_issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let metadata = SdkString::from_str(&env, "ipfs://QmTest");
     let result =
@@ -9928,7 +9928,7 @@ fn test_metadata_ipfs_cid_format() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     // Test typical IPFS CID (46 characters)
     let ipfs_cid = SdkString::from_str(&env, "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG");
@@ -9948,7 +9948,7 @@ fn test_metadata_https_url_format() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     let https_url = SdkString::from_str(&env, "https://api.example.com/metadata/token123.json");
     let result =
@@ -9967,7 +9967,7 @@ fn test_metadata_content_hash_format() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1000, &token, &0, &None);
 
     // SHA256 hash as hex string
     let content_hash = SdkString::from_str(
@@ -10063,7 +10063,7 @@ mod regression {
         let payout_asset = Address::generate(&env);
 
         // Act: Perform the operation
-        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
         // Assert: Verify correct behavior
         let offering = client.get_offering(&issuer, &symbol_short!("def"), &token);
@@ -10322,7 +10322,7 @@ mod regression {
             &1_000,
             &payout_asset,
             &0,
-        );
+        , &None);
         (client, admin, token, payout_asset)
     }
 
@@ -10764,10 +10764,10 @@ mod regression {
         let p1 = Address::generate(&env);
         let p2 = Address::generate(&env);
         let p3 = Address::generate(&env);
-        client.register_offering(&issuer, &symbol_short!("def"), &t0, &100, &p0, &0);
-        client.register_offering(&issuer, &symbol_short!("def"), &t1, &200, &p1, &0);
-        client.register_offering(&issuer, &symbol_short!("def"), &t2, &300, &p2, &0);
-        client.register_offering(&issuer, &symbol_short!("def"), &t3, &400, &p3, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &t0, &100, &p0, &0, &None);
+        client.register_offering(&issuer, &symbol_short!("def"), &t1, &200, &p1, &0, &None);
+        client.register_offering(&issuer, &symbol_short!("def"), &t2, &300, &p2, &0, &None);
+        client.register_offering(&issuer, &symbol_short!("def"), &t3, &400, &p3, &0, &None);
         let (page, _) = client.get_offerings_page(&issuer, &symbol_short!("def"), &0, &10);
         assert_eq!(page.len(), 4);
         assert_eq!(page.get(0).clone().unwrap().token, t0);
@@ -10786,10 +10786,10 @@ mod regression {
         let p1 = Address::generate(&env);
         let p2 = Address::generate(&env);
         let p3 = Address::generate(&env);
-        client.register_offering(&issuer, &symbol_short!("def"), &t0, &100, &p0, &0);
-        client.register_offering(&issuer, &symbol_short!("def"), &t1, &200, &p1, &0);
-        client.register_offering(&issuer, &symbol_short!("def"), &t2, &300, &p2, &0);
-        client.register_offering(&issuer, &symbol_short!("def"), &t3, &400, &p3, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &t0, &100, &p0, &0, &None);
+        client.register_offering(&issuer, &symbol_short!("def"), &t1, &200, &p1, &0, &None);
+        client.register_offering(&issuer, &symbol_short!("def"), &t2, &300, &p2, &0, &None);
+        client.register_offering(&issuer, &symbol_short!("def"), &t3, &400, &p3, &0, &None);
         let (page, _) = client.get_offerings_page(&issuer, &symbol_short!("def"), &0, &10);
         assert_eq!(page.len(), 4);
         assert_eq!(page.get(0).clone().unwrap().token, t0);
@@ -10883,7 +10883,7 @@ mod regression {
         let v0 = client.get_version();
         let token = Address::generate(&env);
         let payout_asset = Address::generate(&env);
-        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
         assert_eq!(client.get_version(), v0);
     }
 
@@ -11026,7 +11026,7 @@ mod regression {
         let token = Address::generate(&env);
         let payout = Address::generate(&env);
 
-        client.register_offering(&issuer, &symbol_short!("def"), &token, &500, &payout, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &token, &500, &payout, &0, &None);
 
         let result = client.get_offering(&issuer, &symbol_short!("def"), &token);
         assert!(result.is_some());
@@ -11048,7 +11048,7 @@ mod regression {
         let mut target_token = Address::generate(&env);
         for i in 0..10u32 {
             let t = Address::generate(&env);
-            client.register_offering(&issuer, &symbol_short!("def"), &t, &(i * 100), &payout, &0);
+            client.register_offering(&issuer, &symbol_short!("def"), &t, &(i * 100), &payout, &0, &None);
             if i == 9 {
                 target_token = t;
             }
@@ -11076,7 +11076,7 @@ mod regression {
             &300,
             &payout,
             &0,
-        );
+        , &None);
         client.propose_issuer_transfer(&old_issuer, &symbol_short!("def"), &token, &new_issuer);
         client.accept_issuer_transfer(&new_issuer, &symbol_short!("def"), &token);
 
@@ -11106,7 +11106,7 @@ mod regression {
             &300,
             &payout,
             &0,
-        );
+        , &None);
         client.propose_issuer_transfer(&old_issuer, &symbol_short!("def"), &token, &new_issuer);
         client.accept_issuer_transfer(&new_issuer, &symbol_short!("def"), &token);
 
@@ -11374,7 +11374,7 @@ mod admin_rotation_edge {
         let payout_asset = Address::generate(&env);
         let new_admin = Address::generate(&env);
 
-        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
         client.propose_admin_rotation(&new_admin);
         client.accept_admin_rotation(&new_admin);
@@ -11453,7 +11453,7 @@ mod admin_rotation_integration {
         let investor = Address::generate(&env);
         let new_admin = Address::generate(&env);
 
-        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+        client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
         client.blacklist_add(&issuer, &issuer, &symbol_short!("def"), &token, &investor);
 
         client.propose_admin_rotation(&new_admin);
@@ -11842,7 +11842,7 @@ fn test_offerings_page_pagination_25_offerings() {
     for i in 0..25 {
         let token = Address::generate(&env);
         tokens.push_back(token.clone());
-        client.register_offering(&issuer1, &ns, &token, &(1000 + i * 100), &token, &0);
+        client.register_offering(&issuer1, &ns, &token, &(1000 + i * 100), &token, &0, &None);
     }
 
     // Test 1: Page through with limit=10
@@ -11881,7 +11881,7 @@ fn test_offerings_page_edge_cases() {
     // Register 10 offerings
     for i in 0..10 {
         let token = Address::generate(&env);
-        client.register_offering(&issuer, &ns, &token, &1000, &token, &0);
+        client.register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
     }
 
     // Edge case 1: start == count (10 offerings, start at 10)
@@ -11919,10 +11919,10 @@ fn test_offerings_page_ordering_deterministic() {
     let t2 = Address::generate(&env);
     let t3 = Address::generate(&env);
 
-    client.register_offering(&issuer, &ns, &t0, &100, &t0, &0);
-    client.register_offering(&issuer, &ns, &t1, &200, &t1, &0);
-    client.register_offering(&issuer, &ns, &t2, &300, &t2, &0);
-    client.register_offering(&issuer, &ns, &t3, &400, &t3, &0);
+    client.register_offering(&issuer, &ns, &t0, &100, &t0, &0, &None);
+    client.register_offering(&issuer, &ns, &t1, &200, &t1, &0, &None);
+    client.register_offering(&issuer, &ns, &t2, &300, &t2, &0, &None);
+    client.register_offering(&issuer, &ns, &t3, &400, &t3, &0, &None);
 
     // Retrieve all pages and verify ordering
     let (page1, cursor1) = client.get_offerings_page(&issuer, &ns, &0, &2);
@@ -11974,9 +11974,9 @@ fn test_offerings_page_after_issuer_transfer() {
     let t2 = Address::generate(&env);
     let t3 = Address::generate(&env);
 
-    client.register_offering(&issuer1, &ns, &t1, &100, &t1, &0);
-    client.register_offering(&issuer1, &ns, &t2, &200, &t2, &0);
-    client.register_offering(&issuer1, &ns, &t3, &300, &t3, &0);
+    client.register_offering(&issuer1, &ns, &t1, &100, &t1, &0, &None);
+    client.register_offering(&issuer1, &ns, &t2, &200, &t2, &0, &None);
+    client.register_offering(&issuer1, &ns, &t3, &300, &t3, &0, &None);
 
     // Verify issuer1 has 3 offerings
     let (page1_before, _) = client.get_offerings_page(&issuer1, &ns, &0, &20);
@@ -12013,7 +12013,7 @@ fn test_issuer_transfer_migrates_all_configs() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
 
-    client.register_offering(&old_issuer, &ns, &token, &1000, &payout_asset, &0);
+    client.register_offering(&old_issuer, &ns, &token, &1000, &payout_asset, &0, &None);
 
     // 1. Set concentration
     client.set_concentration_limit(&old_issuer, &ns, &token, &5000, &true);
diff --git a/src/test_auth.rs b/src/test_auth.rs
index 565fa5e..0484e6f 100644
--- a/src/test_auth.rs
+++ b/src/test_auth.rs
@@ -100,7 +100,7 @@ fn setup_offering(env: &Env, client: &RevoraRevenueShareClient) -> (Address, Add
     let issuer = Address::generate(env);
     let token = Address::generate(env);
     client.set_admin(&issuer);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     (issuer, token)
 }
 
@@ -564,7 +564,7 @@ fn register_offering_missing_auth_no_mutation() {
         &1_000,
         &token,
         &0,
-    );
+    , &None);
     assert!(result.is_err());
     assert_eq!(client.get_offering_count(&issuer, &symbol_short!("def")), 0);
     assert_eq!(
@@ -619,7 +619,7 @@ fn blacklist_remove_wrong_caller_no_mutation() {
     let token = Address::generate(&env);
     let investor = Address::generate(&env);
     client.set_admin(&issuer);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     client.blacklist_add(&issuer, &issuer, &symbol_short!("def"), &token, &investor);
     let attacker = Address::generate(&env);
     // Any authenticated caller can remove; with mock_all_auths this succeeds.
@@ -668,8 +668,8 @@ fn cross_offering_confusion_wrong_issuer_no_mutation() {
     let token_b = Address::generate(&env);
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer_a, &symbol_short!("def"), &token_a, &1_000, &token_a, &0);
-    client.register_offering(&issuer_b, &symbol_short!("def"), &token_b, &1_000, &token_b, &0);
+    client.register_offering(&issuer_a, &symbol_short!("def"), &token_a, &1_000, &token_a, &0, &None);
+    client.register_offering(&issuer_b, &symbol_short!("def"), &token_b, &1_000, &token_b, &0, &None);
 
     // Issuer B tries to set a share on Issuer A's token.
     let result = client.try_set_holder_share(
@@ -698,8 +698,8 @@ fn cross_offering_concentration_limit_wrong_issuer() {
     let token_a = Address::generate(&env);
     let token_b = Address::generate(&env);
 
-    client.register_offering(&issuer_a, &symbol_short!("def"), &token_a, &1_000, &token_a, &0);
-    client.register_offering(&issuer_b, &symbol_short!("def"), &token_b, &1_000, &token_b, &0);
+    client.register_offering(&issuer_a, &symbol_short!("def"), &token_a, &1_000, &token_a, &0, &None);
+    client.register_offering(&issuer_b, &symbol_short!("def"), &token_b, &1_000, &token_b, &0, &None);
 
     let result = client.try_set_concentration_limit(
         &issuer_a,
@@ -729,7 +729,7 @@ fn cross_namespace_confusion_wrong_namespace() {
     let holder = Address::generate(&env);
 
     // Register only in namespace "ns1".
-    client.register_offering(&issuer, &symbol_short!("ns1"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("ns1"), &token, &1_000, &token, &0, &None);
 
     // Attempt to set a share in the unregistered namespace "ns2".
     let result = client.try_set_holder_share(
@@ -824,7 +824,7 @@ fn register_offering_blocked_when_frozen() {
         &1_000,
         &token,
         &0,
-    );
+    , &None);
     assert_eq!(result, Err(Ok(RevoraError::ContractFrozen)));
 }
 
@@ -973,7 +973,7 @@ fn register_offering_invalid_bps_returns_typed_error() {
         &10_001u32,
         &token,
         &0,
-    );
+    , &None);
     assert_eq!(result, Err(Ok(RevoraError::InvalidRevenueShareBps)));
     assert_eq!(client.get_offering_count(&issuer, &symbol_short!("def")), 0);
 }
@@ -1071,8 +1071,8 @@ fn two_issuers_independent_settings() {
     let token_b = Address::generate(&env);
     let holder = Address::generate(&env);
 
-    client.register_offering(&issuer_a, &symbol_short!("def"), &token_a, &1_000, &token_a, &0);
-    client.register_offering(&issuer_b, &symbol_short!("def"), &token_b, &2_000, &token_b, &0);
+    client.register_offering(&issuer_a, &symbol_short!("def"), &token_a, &1_000, &token_a, &0, &None);
+    client.register_offering(&issuer_b, &symbol_short!("def"), &token_b, &2_000, &token_b, &0, &None);
 
     // Issuer A sets a holder share.
     client.set_holder_share(&issuer_a, &symbol_short!("def"), &token_a, &holder, &1_000u32);
diff --git a/src/test_blacklist_batch_gas.rs b/src/test_blacklist_batch_gas.rs
index 4575eef..805e697 100644
--- a/src/test_blacklist_batch_gas.rs
+++ b/src/test_blacklist_batch_gas.rs
@@ -21,7 +21,7 @@ fn blacklist_add_many_gas_bound_worst_case() {
 
     // Initialize and register offering
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1000u32, &token, &0_i128);
+    client.register_offering(&issuer, &ns, &token, &1000u32, &token, &0_i128, &None);
 
     // Prefill blacklist to half the default cap (MAX_BLACKLIST_SIZE = 200 -> 100)
     let mut prefilled: Vec<Address> = Vec::new(&env);
diff --git a/src/test_claim_transfer_fail.rs b/src/test_claim_transfer_fail.rs
index 0087d0f..cc8bc2f 100644
--- a/src/test_claim_transfer_fail.rs
+++ b/src/test_claim_transfer_fail.rs
@@ -226,7 +226,7 @@ fn setup_claim_fail() -> (
         &10_000,
         &fail_token_id,
         &0,
-    );
+    , &None);
     revora.set_holder_share(&issuer, &symbol_short!("def"), &offering_token, &holder, &10_000);
 
     // Mint to issuer and deposit — transfer direction is issuer→contract, not yet failing
@@ -438,22 +438,24 @@ fn claim_transfer_fail_does_not_affect_sibling_offering() {
     // Register a second offering with a normal Stellar asset token
     let offering_token_b = Address::generate(&env);
     let admin_b = Address::generate(&env);
-
+    let payment_token_b = env.register_stellar_asset_contract_v2(admin_b.clone());
+    let payment_token_admin = token::StellarAssetClient::new(&env, &payment_token_b.address());
+    payment_token_admin.mint(&issuer, &100_000);
 
     revora.register_offering(
         &issuer,
         &symbol_short!("def"),
         &offering_token_b,
         &10_000,
-
+        &payment_token_b.address(),
         &0,
-    );
+    , &None);
     revora.set_holder_share(&issuer, &symbol_short!("def"), &offering_token_b, &holder, &10_000);
     revora.deposit_revenue(
         &issuer,
         &symbol_short!("def"),
         &offering_token_b,
-
+        &payment_token_b.address(),
         &100_000,
         &1,
     );
diff --git a/src/test_close_period.rs b/src/test_close_period.rs
index b376be7..b5fd2bf 100644
--- a/src/test_close_period.rs
+++ b/src/test_close_period.rs
@@ -60,7 +60,7 @@ fn setup_offering() -> (Env, RevoraRevenueShareClient<'static>, Address, Address
         &10_000,
         &payment_token,
         &0,
-    );
+    , &None);
 
     (env, client, issuer, offering_token, payment_token)
 }
diff --git a/src/test_compute_share_invariants.rs b/src/test_compute_share_invariants.rs
index f9452e6..acf2844 100644
--- a/src/test_compute_share_invariants.rs
+++ b/src/test_compute_share_invariants.rs
@@ -48,6 +48,9 @@
 
 #![cfg(test)]
 
+extern crate std;
+use std::format;
+
 use crate::{RevoraRevenueShare, RevoraRevenueShareClient, RoundingMode};
 use soroban_sdk::{testutils::Address as _, Address, Env};
 
@@ -589,8 +592,8 @@ fn remainder_product_bound_holds_for_all_bps() {
         20_000,
         100_000,
         1_000_000,
-        i128::MAX / 10_000 * 10_000 + 9_999, // Max remainder
-        i128::MIN / 10_000 * 10_000 - 9_999,   // Min remainder
+        (i128::MAX / 10_000 - 1) * 10_000 + 9_999, // Max remainder near MAX
+        (i128::MIN / 10_000 + 1) * 10_000 - 9_999,   // Min remainder near MIN
     ];
 
     let bps_values = [1_u32, 100, 1_000, 5_000, 9_999, 10_000];
@@ -636,7 +639,7 @@ fn checked_mul_defense_in_depth_prevents_overflow() {
     ];
 
     for &amount in &extreme_amounts {
-        for &bps in [1_u32, 5_000, 10_000] {
+        for bps in [1_u32, 5_000, 10_000] {
             let result = c.compute_share(&amount, &bps, &RoundingMode::Truncation);
             // Should never panic and should always satisfy bounds
             assert_bounds(result, amount, &format!("Extreme amount={amount} bps={bps}"));
diff --git a/src/test_cross_contract.rs b/src/test_cross_contract.rs
index 3cfee48..646e4c1 100644
--- a/src/test_cross_contract.rs
+++ b/src/test_cross_contract.rs
@@ -193,7 +193,7 @@ fn cross_contract_registry_check_before_offering() {
     // Step 3: Now register offering in Revora (after registry approval)
     // In production, register_offering would call registry.is_approved() internally
     assert!(registry.is_approved(&token));
-    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
 
     // Verify offering was created
     let offering = revora.get_offering(&issuer, &symbol_short!("def"), &token);
@@ -285,7 +285,7 @@ fn cross_contract_oracle_revenue_valuation() {
     let payout_asset = Address::generate(&env);
 
     // Register offering
-    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
 
     // Report revenue
     revora.report_revenue(
@@ -356,7 +356,7 @@ fn cross_contract_full_workflow_registry_then_offering() {
     assert!(registry.is_approved(&token));
 
     // Step 3: Register offering in Revora
-    revora.register_offering(&issuer, &symbol_short!("def"), &token, &3_000, &payout_asset, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token, &3_000, &payout_asset, &0, &None);
 
     // Step 4: Report revenue
     revora.report_revenue(
@@ -430,7 +430,7 @@ fn cross_contract_error_in_registry_does_not_affect_revora() {
 
     // Register token and offering
     registry.register_token(&admin, &token);
-    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
 
     // Cause an error in registry (duplicate registration)
     let err = registry.try_register_token(&admin, &token);
@@ -458,7 +458,7 @@ fn cross_contract_revora_operations_independent_of_oracle_state() {
     let payout_asset = Address::generate(&env);
 
     // Revora works fine without any oracle prices set
-    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
     revora.report_revenue(
         &issuer,
         &symbol_short!("def"),
@@ -502,13 +502,13 @@ fn cross_contract_concurrent_state_changes() {
     let payout_3 = Address::generate(&env);
 
     registry.register_token(&admin, &token_1);
-    revora.register_offering(&issuer, &symbol_short!("def"), &token_1, &1_000, &payout_1, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token_1, &1_000, &payout_1, &0, &None);
 
     registry.register_token(&admin, &token_2);
-    revora.register_offering(&issuer, &symbol_short!("def"), &token_2, &2_000, &payout_2, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token_2, &2_000, &payout_2, &0, &None);
 
     registry.register_token(&admin, &token_3);
-    revora.register_offering(&issuer, &symbol_short!("def"), &token_3, &3_000, &payout_3, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token_3, &3_000, &payout_3, &0, &None);
 
     // Verify both contracts have consistent state
     assert_eq!(registry.get_token_count(), 3);
@@ -542,7 +542,7 @@ fn cross_contract_oracle_price_updates_across_revenue_reports() {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
 
-    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    revora.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
 
     // Report revenue at $1.00
     revora.report_revenue(
@@ -624,7 +624,7 @@ fn cross_contract_stress_revora_with_registry_and_oracle() {
             &((i + 1) * 1_000),
             &payout,
             &0,
-        );
+        , &None);
         oracle.set_price(&admin, &payout, &((i as i128 + 1) * 1_000_000), &1000);
         revora.report_revenue(
             &issuer,
diff --git a/src/test_cross_contract_transfer_fail.rs b/src/test_cross_contract_transfer_fail.rs
index be4cc10..e4208ca 100644
--- a/src/test_cross_contract_transfer_fail.rs
+++ b/src/test_cross_contract_transfer_fail.rs
@@ -85,7 +85,7 @@ fn setup() -> (Env, RevoraRevenueShareClient<'static>, Address, Address, Address
         &5_000,
         &payment_token,
         &0,
-    );
+    , &None);
 
     (env, client, contract_id, issuer, offering_token, payment_token, pt_admin)
 }
@@ -427,7 +427,7 @@ fn transfer_fail_in_one_offering_does_not_affect_sibling_offering() {
         &5_000,
         &payment_token_b,
         &0,
-    );
+    , &None);
 
     // Fund only offering B
     mint(&env, &payment_token_b, &issuer, 100_000);
diff --git a/src/test_duplicates.rs b/src/test_duplicates.rs
index abf27e8..85bfc5f 100644
--- a/src/test_duplicates.rs
+++ b/src/test_duplicates.rs
@@ -27,7 +27,7 @@ fn setup_offering() -> (Env, RevoraRevenueShareClient<'static>, Address, Address
     let payout_asset = Address::generate(&env);
     let namespace = symbol_short!("ns");
 
-    client.register_offering(&issuer, &namespace, &token, &5000, &payout_asset, &0);
+    client.register_offering(&issuer, &namespace, &token, &5000, &payout_asset, &0, &None);
 
     (env, client, issuer, token, payout_asset)
 }
@@ -52,14 +52,14 @@ fn test_register_duplicate_offering_is_idempotent() {
     let payout_asset = Address::generate(&env);
 
     // First registration
-    client.register_offering(&issuer, &namespace, &token, &5000, &payout_asset, &0);
+    client.register_offering(&issuer, &namespace, &token, &5000, &payout_asset, &0, &None);
     assert_eq!(client.get_offering_count(&issuer, &namespace), 1);
 
     let offering1 = client.get_offering(&issuer, &namespace, &token).unwrap();
     assert_eq!(offering1.revenue_share_bps, 5000);
 
     // Second registration (same identity, different bps)
-    client.register_offering(&issuer, &namespace, &token, &6000, &payout_asset, &0);
+    client.register_offering(&issuer, &namespace, &token, &6000, &payout_asset, &0, &None);
 
     // Count should still be 1
     assert_eq!(client.get_offering_count(&issuer, &namespace), 1);
@@ -79,9 +79,9 @@ fn test_pagination_stability_with_idempotency() {
     let token_b = Address::generate(&env);
 
     // Register A, then B, then A again
-    client.register_offering(&issuer, &namespace, &token_a, &1000, &payout_asset, &0);
-    client.register_offering(&issuer, &namespace, &token_b, &2000, &payout_asset, &0);
-    client.register_offering(&issuer, &namespace, &token_a, &3000, &payout_asset, &0);
+    client.register_offering(&issuer, &namespace, &token_a, &1000, &payout_asset, &0, &None);
+    client.register_offering(&issuer, &namespace, &token_b, &2000, &payout_asset, &0, &None);
+    client.register_offering(&issuer, &namespace, &token_a, &3000, &payout_asset, &0, &None);
 
     let (offerings, _) = client.get_offerings_page(&issuer, &namespace, &0, &10);
 
@@ -98,8 +98,8 @@ fn test_get_offering_matches_first_registration() {
     let namespace = symbol_short!("ns");
     let payout_asset = Address::generate(&env);
 
-    client.register_offering(&issuer, &namespace, &token, &1000, &payout_asset, &0);
-    client.register_offering(&issuer, &namespace, &token, &2000, &payout_asset, &0);
+    client.register_offering(&issuer, &namespace, &token, &1000, &payout_asset, &0, &None);
+    client.register_offering(&issuer, &namespace, &token, &2000, &payout_asset, &0, &None);
 
     let offering = client.get_offering(&issuer, &namespace, &token).unwrap();
     assert_eq!(offering.revenue_share_bps, 1000);
diff --git a/src/test_event_indexed_v2.rs b/src/test_event_indexed_v2.rs
index 1488b85..4b2a46d 100644
--- a/src/test_event_indexed_v2.rs
+++ b/src/test_event_indexed_v2.rs
@@ -37,7 +37,7 @@ fn setup() -> (Env, RevoraRevenueShareClient<'static>, Address, Symbol, Address,
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &2500, &payout, &0);
+    client.register_offering(&issuer, &ns, &token, &2500, &payout, &0, &None);
     (env, client, issuer, ns, token, payout)
 }
 
@@ -205,7 +205,7 @@ fn event_indexed_v2_claim_topic_and_data_shape() {
     soroban_sdk::token::StellarAssetClient::new(&env, &payout).mint(&issuer, &1_000_000);
 
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &2500, &payout, &0);
+    client.register_offering(&issuer, &ns, &token, &2500, &payout, &0, &None);
 
     let holder = Address::generate(&env);
     client.deposit_revenue(&issuer, &ns, &token, &payout, &100_000, &1);
@@ -243,7 +243,7 @@ fn event_indexed_v2_claim_period_id_always_zero() {
     soroban_sdk::token::StellarAssetClient::new(&env, &payout).mint(&issuer, &1_000_000);
 
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &2500, &payout, &0);
+    client.register_offering(&issuer, &ns, &token, &2500, &payout, &0, &None);
 
     let holder = Address::generate(&env);
     client.deposit_revenue(&issuer, &ns, &token, &payout, &100_000, &1);
@@ -273,8 +273,8 @@ fn event_indexed_v2_payout_asset_bound_correctly_per_offering() {
     let payout_a = Address::generate(&env);
     let payout_b = Address::generate(&env);
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token_a, &2500, &payout_a, &0);
-    client.register_offering(&issuer, &ns, &token_b, &2500, &payout_b, &0);
+    client.register_offering(&issuer, &ns, &token_a, &2500, &payout_a, &0, &None);
+    client.register_offering(&issuer, &ns, &token_b, &2500, &payout_b, &0, &None);
 
     let before_a = env.events().all().len();
     client.report_revenue(&issuer, &ns, &token_a, &payout_a, &10_000, &1, &false);
diff --git a/src/test_freeze_matrix.rs b/src/test_freeze_matrix.rs
index 110b7fd..5238a9b 100644
--- a/src/test_freeze_matrix.rs
+++ b/src/test_freeze_matrix.rs
@@ -80,7 +80,7 @@ fn frozen_setup(
     let issuer = admin.clone();
     let token = Address::generate(env);
     let payout_asset = Address::generate(env);
-    client.register_offering(&issuer, &symbol_short!("ns"), &token, &1_000u32, &payout_asset, &0i128);
+    client.register_offering(&issuer, &symbol_short!("ns"), &token, &1_000u32, &payout_asset, &0i128, &None);
 
     // Freeze the contract — all subsequent mutating calls must return ContractFrozen.
     client.freeze();
@@ -102,7 +102,7 @@ fn frozen_register_offering_returns_contract_frozen() {
         &500u32,
         &payout_asset,
         &0i128,
-    );
+    , &None);
     assert_frozen_err(result);
     // Verify no partial write: offering must not exist.
     assert!(client.get_offering(&issuer, &symbol_short!("ns2"), &new_token).is_none());
@@ -482,7 +482,7 @@ fn frozen_claim_is_not_blocked() {
     let issuer = admin.clone();
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("ns"), &token, &1_000u32, &payout_asset, &0i128);
+    client.register_offering(&issuer, &symbol_short!("ns"), &token, &1_000u32, &payout_asset, &0i128, &None);
 
     let holder = Address::generate(&env);
     client.set_holder_share(&issuer, &symbol_short!("ns"), &token, &holder, &1_000u32);
diff --git a/src/test_indexer_fixtures.rs b/src/test_indexer_fixtures.rs
index 8ea046b..6f19fe5 100644
--- a/src/test_indexer_fixtures.rs
+++ b/src/test_indexer_fixtures.rs
@@ -16,7 +16,7 @@ fn setup_with_offering(env: &Env) -> (RevoraRevenueShareClient, Address, Address
     let token = Address::generate(env);
     let payout_asset = Address::generate(env);
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&admin, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&admin, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     (client, admin, token, payout_asset)
 }
 
@@ -130,7 +130,7 @@ fn register_offering_emits_ofr_reg2_v2_event() {
     client.initialize(&admin, &None::<Address>, &None::<bool>);
 
     let before = env.events().all().len();
-    client.register_offering(&admin, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&admin, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     let events = env.events().all();
     assert!(events.len() > before, "register_offering must emit at least one event");
@@ -156,7 +156,7 @@ fn register_offering_v2_event_data_starts_with_version_2() {
     client.initialize(&admin, &None::<Address>, &None::<bool>);
 
     let before = env.events().all().len();
-    client.register_offering(&admin, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&admin, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
 
     let events = env.events().all();
     let new_events = events.slice(before as u32..);
diff --git a/src/test_min_revenue_threshold_boundary.rs b/src/test_min_revenue_threshold_boundary.rs
index f2f961f..d9d0366 100644
--- a/src/test_min_revenue_threshold_boundary.rs
+++ b/src/test_min_revenue_threshold_boundary.rs
@@ -32,7 +32,7 @@ fn setup() -> (Env, Address, Address, Address, Address) {
     let token = Address::generate(&env);
     let payout = Address::generate(&env);
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout, &0, &None);
     (env, contract_id, issuer, token, payout)
 }
 
diff --git a/src/test_namespaces.rs b/src/test_namespaces.rs
index dcfe444..e754529 100644
--- a/src/test_namespaces.rs
+++ b/src/test_namespaces.rs
@@ -25,9 +25,9 @@ fn test_namespace_isolation() {
     let ns_2 = symbol_short!("ns2");
 
     // Issuer A registers in ns1
-    client.register_offering(&issuer_a, &ns_1, &token, &1000, &token, &0);
+    client.register_offering(&issuer_a, &ns_1, &token, &1000, &token, &0, &None);
     // Issuer B registers in ns2 with SAME token
-    client.register_offering(&issuer_b, &ns_2, &token, &2000, &token, &0);
+    client.register_offering(&issuer_b, &ns_2, &token, &2000, &token, &0, &None);
 
     // Set holder shares differently
     let holder = Address::generate(&env);
@@ -64,8 +64,8 @@ fn test_same_issuer_different_namespaces() {
     let ns_1 = symbol_short!("prod");
     let ns_2 = symbol_short!("stg");
 
-    client.register_offering(&issuer, &ns_1, &token, &1000, &token, &0);
-    client.register_offering(&issuer, &ns_2, &token, &2000, &token, &0);
+    client.register_offering(&issuer, &ns_1, &token, &1000, &token, &0, &None);
+    client.register_offering(&issuer, &ns_2, &token, &2000, &token, &0, &None);
 
     client.set_snapshot_config(&issuer, &ns_1, &token, &true);
     client.set_snapshot_config(&issuer, &ns_2, &token, &false);
@@ -88,8 +88,8 @@ fn test_cross_namespace_blacklist_isolation() {
     let investor = Address::generate(&env);
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns_1, &token, &1000, &token, &0);
-    client.register_offering(&issuer, &ns_2, &token, &1000, &token, &0);
+    client.register_offering(&issuer, &ns_1, &token, &1000, &token, &0, &None);
+    client.register_offering(&issuer, &ns_2, &token, &1000, &token, &0, &None);
 
     // Blacklist in NS 1
     client.blacklist_add(&issuer, &issuer, &ns_1, &token, &investor);
@@ -131,7 +131,7 @@ fn test_unauthorized_issuer_access_fails() {
     let token = Address::generate(&env);
     let ns_1 = symbol_short!("ns1");
 
-    client.register_offering(&issuer_real, &ns_1, &token, &1000, &token, &0);
+    client.register_offering(&issuer_real, &ns_1, &token, &1000, &token, &0, &None);
 
     // Attacker tries to blacklist for real issuer's offering
     // Note: mock_all_auths will allow the call to reach the contract,
@@ -165,7 +165,7 @@ fn test_transfer_maintains_namespace_isolation() {
     let token_1 = Address::generate(&env);
     let ns_1 = symbol_short!("ns1");
 
-    client.register_offering(&issuer_a, &ns_1, &token_1, &1000, &token_1, &0);
+    client.register_offering(&issuer_a, &ns_1, &token_1, &1000, &token_1, &0, &None);
     client.set_claim_delay(&issuer_a, &ns_1, &token_1, &3600);
 
     // Transfer to Issuer B
@@ -198,10 +198,10 @@ fn test_duplicate_registration_fails() {
     let ns = symbol_short!("ns1");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1000, &token, &0);
+    client.register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
 
     // Exact same registration should fail
-    let res = client.try_register_offering(&issuer, &ns, &token, &1000, &token, &0);
+    let res = client.try_register_offering(&issuer, &ns, &token, &1000, &token, &0, &None);
     assert!(res.is_err());
 }
 
@@ -220,8 +220,8 @@ fn test_aggregation_across_namespaces() {
     let ns_2 = symbol_short!("stg");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns_1, &token1, &1000, &token1, &0);
-    client.register_offering(&issuer, &ns_2, &token2, &1000, &token2, &0);
+    client.register_offering(&issuer, &ns_1, &token1, &1000, &token1, &0, &None);
+    client.register_offering(&issuer, &ns_2, &token2, &1000, &token2, &0, &None);
 
     // Report revenue in both namespaces
     client.report_revenue(&issuer, &ns_1, &token1, &token1, &50000, &1, &false);
@@ -252,7 +252,7 @@ fn test_blacklist_precedence_over_whitelist() {
 
     // Initialize and register offering
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Add investor to whitelist first
     client.whitelist_add(&issuer, &issuer, &ns, &token, &investor);
@@ -296,7 +296,7 @@ fn test_blacklist_unaffected_by_whitelist_removal() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Add to both lists
     client.whitelist_add(&issuer, &issuer, &ns, &token, &investor);
@@ -325,7 +325,7 @@ fn test_blacklist_removal_doesnt_whitelist() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Blacklist investor
     client.blacklist_add(&issuer, &issuer, &ns, &token, &investor);
@@ -353,7 +353,7 @@ fn test_blacklist_add_idempotent() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Add to blacklist multiple times
     client.blacklist_add(&issuer, &issuer, &ns, &token, &investor);
@@ -379,7 +379,7 @@ fn test_blacklist_remove_idempotent() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Remove from empty blacklist multiple times (should not panic)
     client.blacklist_remove(&issuer, &issuer, &ns, &token, &investor);
@@ -407,7 +407,7 @@ fn test_mixed_sequence_with_share_updates() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Set initial shares
     client.set_holder_share(&issuer, &ns, &token, &holder_a, &5000);
@@ -476,7 +476,7 @@ fn test_whitelist_only_mode() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Add only one address to whitelist
     client.whitelist_add(&issuer, &issuer, &ns, &token, &whitelisted);
@@ -532,7 +532,7 @@ fn test_blacklist_only_mode() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Add only one address to blacklist
     client.blacklist_add(&issuer, &issuer, &ns, &token, &blacklisted);
@@ -587,7 +587,7 @@ fn test_complex_add_remove_sequence() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Complex sequence
     client.blacklist_add(&issuer, &issuer, &ns, &token, &investor);
@@ -636,7 +636,7 @@ fn test_multiple_investors_precedence() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // inv_a: whitelisted only
     client.whitelist_add(&issuer, &issuer, &ns, &token, &inv_a);
@@ -711,7 +711,7 @@ fn test_whitelist_disable_changes_eligibility() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // Enable whitelist
     client.whitelist_add(&issuer, &issuer, &ns, &token, &whitelisted);
@@ -771,7 +771,7 @@ fn test_no_lists_all_eligible() {
     let ns = symbol_short!("def");
 
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &ns, &token, &1_000, &payout_asset, &0, &None);
 
     // No blacklist or whitelist entries
     assert!(!client.is_whitelist_enabled(&issuer, &ns, &token));
diff --git a/src/test_override_audit_trail.rs b/src/test_override_audit_trail.rs
index da0085f..dbe9011 100644
--- a/src/test_override_audit_trail.rs
+++ b/src/test_override_audit_trail.rs
@@ -46,7 +46,7 @@ fn setup() -> (Env, Address, Address, Address, Address) {
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
     client.initialize(&issuer, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &payout_asset, &0, &None);
     (env, contract_id, issuer, token, payout_asset)
 }
 
diff --git a/src/test_pause_tiers.rs b/src/test_pause_tiers.rs
index 8efa814..642d5fc 100644
--- a/src/test_pause_tiers.rs
+++ b/src/test_pause_tiers.rs
@@ -71,7 +71,7 @@ fn setup_with_offering(
         &10_000,
         &payment_token.address(),
         &0,
-    );
+    , &None);
     client.set_holder_share(&issuer, &symbol_short!("def"), &offering_token, &holder, &10_000);
 
     // Mint to issuer and deposit period 1
@@ -229,7 +229,7 @@ fn soft_pause_register_offering_blocked() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let result =
-        client.try_register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+        client.try_register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     assert_eq!(result, Err(Ok(RevoraError::ContractPaused)));
 }
 
@@ -304,7 +304,7 @@ fn hard_pause_register_offering_blocked() {
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
     let result =
-        client.try_register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+        client.try_register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     assert_eq!(result, Err(Ok(RevoraError::ContractPaused)));
 }
 
diff --git a/src/test_period_id_boundary.rs b/src/test_period_id_boundary.rs
index 0da7913..5747e1c 100644
--- a/src/test_period_id_boundary.rs
+++ b/src/test_period_id_boundary.rs
@@ -66,7 +66,7 @@ fn setup_funded() -> (Env, RevoraRevenueShareClient<'static>, Address, Address,
         &1_000,
         &payment_token,
         &0,
-    );
+    , &None);
     mint(&env, &payment_token, &issuer, 1_000_000_000);
     (env, client, issuer, offering_token, payment_token)
 }
@@ -82,7 +82,7 @@ fn report_revenue_zero_period_id_rejected() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     let result =
         client.try_report_revenue(&issuer, &symbol_short!("def"), &token, &token, &100, &0, &false);
@@ -181,7 +181,7 @@ fn report_revenue_period_id_one_accepted() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     let result =
         client.try_report_revenue(&issuer, &symbol_short!("def"), &token, &token, &500, &1, &false);
@@ -196,7 +196,7 @@ fn report_revenue_period_id_max_rejected() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     let result = client.try_report_revenue(
         &issuer,
@@ -218,7 +218,7 @@ fn report_revenue_period_id_near_max_rejected() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     let result = client.try_report_revenue(
         &issuer,
@@ -337,7 +337,7 @@ fn report_revenue_duplicate_without_override_no_state_change() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     client
         .report_revenue(&issuer, &symbol_short!("def"), &token, &token, &500, &7, &false)
@@ -361,7 +361,7 @@ fn report_revenue_duplicate_with_override_updates_state() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     client
         .report_revenue(&issuer, &symbol_short!("def"), &token, &token, &500, &7, &false)
@@ -388,7 +388,7 @@ fn negative_amount_rejected_before_period_id_check() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     // Negative amount with valid period_id
     let r =
@@ -404,7 +404,7 @@ fn zero_amount_accepted_by_report_revenue() {
     let client = make_client(&env);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     let r =
         client.try_report_revenue(&issuer, &symbol_short!("def"), &token, &token, &0, &3, &false);
@@ -439,7 +439,7 @@ fn report_revenue_wrong_issuer_rejected() {
     let issuer = Address::generate(&env);
     let attacker = Address::generate(&env);
     let token = Address::generate(&env);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_report_revenue(
         &attacker,
@@ -495,7 +495,7 @@ fn period_id_isolated_across_offerings() {
         &1_000,
         &payment_token,
         &0,
-    );
+    , &None);
     client.register_offering(
         &issuer_b,
         &symbol_short!("def"),
@@ -503,7 +503,7 @@ fn period_id_isolated_across_offerings() {
         &1_000,
         &payment_token,
         &0,
-    );
+    , &None);
 
     mint(&env, &payment_token, &issuer_a, 1_000_000);
     mint(&env, &payment_token, &issuer_b, 1_000_000);
@@ -536,8 +536,8 @@ fn report_revenue_period_id_isolated_across_offerings() {
     let token_a = Address::generate(&env);
     let token_b = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &1_000, &token_a, &0);
-    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &1_000, &token_b, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_a, &1_000, &token_a, &0, &None);
+    client.register_offering(&issuer, &symbol_short!("def"), &token_b, &1_000, &token_b, &0, &None);
 
     client
         .report_revenue(&issuer, &symbol_short!("def"), &token_a, &token_a, &100, &9, &false)
@@ -565,7 +565,7 @@ fn frozen_contract_rejects_report_revenue() {
     let token = Address::generate(&env);
 
     client.initialize(&admin, &None::<Address>, &None::<bool>);
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &1_000, &token, &0, &None);
     client.freeze();
 
     let r =
@@ -592,7 +592,7 @@ fn frozen_contract_rejects_deposit_revenue() {
         &1_000,
         &payment_token,
         &0,
-    );
+    , &None);
     mint(&env, &payment_token, &issuer, 1_000_000);
     client.freeze();
 
diff --git a/src/test_prove_distribution.rs b/src/test_prove_distribution.rs
index 3ba07a6..2c34cf6 100644
--- a/src/test_prove_distribution.rs
+++ b/src/test_prove_distribution.rs
@@ -42,7 +42,7 @@ fn prove_distribution_normal_case() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     let holder_a = Address::generate(&env);
     let holder_b = Address::generate(&env);
@@ -107,7 +107,7 @@ fn prove_distribution_digest_is_deterministic() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     let holder_a = Address::generate(&env);
     let holder_b = Address::generate(&env);
@@ -163,7 +163,7 @@ fn prove_distribution_ordering_affects_digest() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     let holder_a = Address::generate(&env);
     let holder_b = Address::generate(&env);
@@ -223,7 +223,7 @@ fn prove_distribution_empty_holders() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     mint(&env, &payment_token, &issuer, 10_000_000);
     client.deposit_revenue(
@@ -266,7 +266,7 @@ fn prove_distribution_unknown_period_id_returns_zero_payouts() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     let holder_a = Address::generate(&env);
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder_a, &3_000u32);
@@ -316,7 +316,7 @@ fn prove_distribution_zero_share_bps_yields_zero_payout() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     mint(&env, &payment_token, &issuer, 10_000_000);
     client.deposit_revenue(
@@ -365,7 +365,7 @@ fn prove_distribution_usdc_6_decimals_normalizes_correctly() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     // Configure 6-decimal payment token (USDC-style)
     client.set_payment_token_decimals(&issuer, &symbol_short!("def"), &token, &6u32);
@@ -420,7 +420,7 @@ fn prove_distribution_respects_round_half_up_mode() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
     client.set_rounding_mode(&issuer, &symbol_short!("def"), &token, &RoundingMode::RoundHalfUp);
 
     let holder = Address::generate(&env);
@@ -463,7 +463,7 @@ fn prove_distribution_caps_at_max_chunk_periods() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     mint(&env, &payment_token, &issuer, 1_000_000);
     client.deposit_revenue(
@@ -510,7 +510,7 @@ fn prove_distribution_entry_fields_match() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     let holder = Address::generate(&env);
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &10_000u32);
@@ -560,7 +560,7 @@ fn prove_distribution_different_periods_produce_different_digests() {
         &1_000u32,
         &payment_token,
         &0i128,
-    );
+    , &None);
 
     let holder = Address::generate(&env);
     client.set_holder_share(&issuer, &symbol_short!("def"), &token, &holder, &5_000u32);
diff --git a/src/test_reconciliation_bug.rs b/src/test_reconciliation_bug.rs
index b7ed4b6..27533a4 100644
--- a/src/test_reconciliation_bug.rs
+++ b/src/test_reconciliation_bug.rs
@@ -48,7 +48,7 @@ fn setup_offering_with_payment_token(
     let (payment_token, _pt_admin) = create_payment_token(&env);
 
     // Register offering (5000 bps = 50% revenue share)
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payment_token, &0, &None);
 
     // Mint payment tokens to the issuer so they can deposit
     mint_tokens(&env, &payment_token, &issuer, 10_000_000);
diff --git a/src/test_snapshot_finalization.rs b/src/test_snapshot_finalization.rs
index ba8b388..469f3d5 100644
--- a/src/test_snapshot_finalization.rs
+++ b/src/test_snapshot_finalization.rs
@@ -18,7 +18,7 @@ fn setup_snapshot_test(
     let token = Address::generate(&env);
     let payout_asset = Address::generate(&env);
 
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
     (env, client, issuer, token, payout_asset, contract_id)
 }
 
diff --git a/src/test_snapshot_monotonicity_replay.rs b/src/test_snapshot_monotonicity_replay.rs
index 5957f8d..3a97e5b 100644
--- a/src/test_snapshot_monotonicity_replay.rs
+++ b/src/test_snapshot_monotonicity_replay.rs
@@ -77,7 +77,7 @@ fn setup() -> (Env, RevoraRevenueShareClient<'static>, Address, Address) {
         &5_000,
         &payout_asset,
         &0,
-    );
+    , &None);
 
     // Enable snapshot distribution for this offering.
     client.set_snapshot_config(&issuer, &symbol_short!("def"), &token, &true);
@@ -343,7 +343,7 @@ fn snapshot_replay_is_isolated_per_offering() {
     // Register a second offering (different token, same issuer/namespace).
     let token_b = Address::generate(&env);
     let payout_b = Address::generate(&env);
-    client.register_offering(&issuer, &ns, &token_b, &5_000, &payout_b, &0);
+    client.register_offering(&issuer, &ns, &token_b, &5_000, &payout_b, &0, &None);
     client.set_snapshot_config(&issuer, &ns, &token_b, &true);
 
     // Advance offering A to ref 100.
diff --git a/src/test_snapshot_negative_matrix.rs b/src/test_snapshot_negative_matrix.rs
index 4e85d14..bc8f8c1 100644
--- a/src/test_snapshot_negative_matrix.rs
+++ b/src/test_snapshot_negative_matrix.rs
@@ -72,7 +72,7 @@ fn setup_snapshot_test() -> (Env, RevoraRevenueShareClient<'static>, Address, Ad
     let payout_asset = Address::generate(&env);
 
     // Register offering with payout_asset
-    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0);
+    client.register_offering(&issuer, &symbol_short!("def"), &token, &5_000, &payout_asset, &0, &None);
 
     (env, client, issuer, token, payout_asset, contract_id)
 }
diff --git a/src/test_time_windows.rs b/src/test_time_windows.rs
index 369a95c..f5fab68 100644
--- a/src/test_time_windows.rs
+++ b/src/test_time_windows.rs
@@ -134,7 +134,7 @@ fn setup_with_holder() -> (
         &10_000, // 100% share pool
         &payment_token,
         &0,
-    );
+    , &None);
     mint(&env, &payment_token, &issuer, 10_000_000);
     RevoraRevenueShareClient::new(&env, &cid).set_holder_share(&issuer, &symbol_short!("ns"), &offering_token, &holder, &10_000);
 
@@ -193,7 +193,7 @@ fn report_window_unset_always_open() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     // Verify no window is stored
     assert!(client.get_report_window(&issuer, &symbol_short!("ns"), &token).is_none());
@@ -222,7 +222,7 @@ fn report_window_before_start_is_closed() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     // Window: [1000, 2000]
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
@@ -244,7 +244,7 @@ fn report_window_at_start_is_open_inclusive() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
 
@@ -264,7 +264,7 @@ fn report_window_inside_is_open() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
 
@@ -284,7 +284,7 @@ fn report_window_at_end_is_open_inclusive() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
 
@@ -304,7 +304,7 @@ fn report_window_after_end_is_closed() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
 
@@ -324,7 +324,7 @@ fn report_window_zero_width_open_at_exact_timestamp() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     // start == end: single-second window at T=5000
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &5_000, &5_000);
@@ -345,7 +345,7 @@ fn report_window_zero_width_closed_before() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &5_000, &5_000);
 
@@ -365,7 +365,7 @@ fn report_window_zero_width_closed_after() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &5_000, &5_000);
 
@@ -385,7 +385,7 @@ fn report_window_reconfigured_to_exclude_now_closes_reporting() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     // Initial window: [1000, 3000]; now = 2000 → open
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &3_000);
@@ -411,7 +411,7 @@ fn report_window_reconfigured_to_include_now_opens_reporting() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     // Initial window: [4000, 5000]; now = 2000 → closed
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &4_000, &5_000);
@@ -617,7 +617,7 @@ fn set_report_window_valid_range_accepted() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
     assert!(r.is_ok());
@@ -636,7 +636,7 @@ fn set_report_window_zero_width_accepted() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_set_report_window(&issuer, &symbol_short!("ns"), &token, &5_000, &5_000);
     assert!(r.is_ok(), "zero-width window must be accepted, got {r:?}");
@@ -651,7 +651,7 @@ fn set_report_window_inverted_range_rejected() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_set_report_window(&issuer, &symbol_short!("ns"), &token, &2_000, &1_000);
     assert_eq!(r, Err(Ok(RevoraError::LimitReached)));
@@ -669,7 +669,7 @@ fn set_claim_window_valid_range_accepted() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_set_claim_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
     assert!(r.is_ok());
@@ -688,7 +688,7 @@ fn set_claim_window_zero_width_accepted() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_set_claim_window(&issuer, &symbol_short!("ns"), &token, &5_000, &5_000);
     assert!(r.is_ok(), "zero-width window must be accepted, got {r:?}");
@@ -703,7 +703,7 @@ fn set_claim_window_inverted_range_rejected() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let r = client.try_set_claim_window(&issuer, &symbol_short!("ns"), &token, &2_000, &1_000);
     assert_eq!(r, Err(Ok(RevoraError::LimitReached)));
@@ -945,8 +945,8 @@ fn report_window_is_scoped_per_offering() {
     let token_a = Address::generate(&env);
     let token_b = Address::generate(&env);
 
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token_a, &1_000, &token_a, &0);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token_b, &1_000, &token_b, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token_a, &1_000, &token_a, &0, &None);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token_b, &1_000, &token_b, &0, &None);
 
     // Close offering A's report window; leave B's unset (always open)
     client.set_report_window(&issuer, &symbol_short!("ns"), &token_a, &5_000, &6_000);
@@ -981,10 +981,10 @@ fn claim_window_is_scoped_per_offering() {
 
     RevoraRevenueShareClient::new(&env, &cid).register_offering(
         &issuer, &symbol_short!("ns"), &token_a, &10_000, &payment_token, &0,
-    );
+    , &None);
     RevoraRevenueShareClient::new(&env, &cid).register_offering(
         &issuer, &symbol_short!("ns"), &token_b, &10_000, &payment_token, &0,
-    );
+    , &None);
     mint(&env, &payment_token, &issuer, 10_000_000);
     RevoraRevenueShareClient::new(&env, &cid).set_holder_share(&issuer, &symbol_short!("ns"), &token_a, &holder, &10_000);
     RevoraRevenueShareClient::new(&env, &cid).set_holder_share(&issuer, &symbol_short!("ns"), &token_b, &holder, &10_000);
@@ -1022,7 +1022,7 @@ fn set_report_window_emits_event() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let before = env.events().all().len();
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
@@ -1041,7 +1041,7 @@ fn set_claim_window_emits_event() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     let before = env.events().all().len();
     client.set_claim_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
@@ -1064,7 +1064,7 @@ fn get_report_window_returns_none_when_unset() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     assert!(client.get_report_window(&issuer, &symbol_short!("ns"), &token).is_none());
 }
@@ -1078,7 +1078,7 @@ fn get_claim_window_returns_none_when_unset() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     assert!(client.get_claim_window(&issuer, &symbol_short!("ns"), &token).is_none());
 }
@@ -1092,7 +1092,7 @@ fn get_report_window_returns_correct_values() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_234, &5_678);
     let w = client.get_report_window(&issuer, &symbol_short!("ns"), &token).unwrap();
@@ -1109,7 +1109,7 @@ fn get_claim_window_returns_correct_values() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_claim_window(&issuer, &symbol_short!("ns"), &token, &9_000, &9_999);
     let w = client.get_claim_window(&issuer, &symbol_short!("ns"), &token).unwrap();
@@ -1126,7 +1126,7 @@ fn set_report_window_overwrites_previous() {
     let client = RevoraRevenueShareClient::new(&env, &cid);
     let issuer = Address::generate(&env);
     let token = Address::generate(&env);
-    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0);
+    RevoraRevenueShareClient::new(&env, &cid).register_offering(&issuer, &symbol_short!("ns"), &token, &1_000, &token, &0, &None);
 
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &1_000, &2_000);
     client.set_report_window(&issuer, &symbol_short!("ns"), &token, &3_000, &4_000);