From a6409c98086522febbb4c12932276144b6ee2124 Mon Sep 17 00:00:00 2001
From: Godsmiracle001 <Miraxzeegame@gmail.com>
Date: Sat, 27 Jun 2026 16:51:29 +0100
Subject: [PATCH 1/6] test: add unit tests for issues #487 #489 #491 #492

#487 - distribute_dividend reverts when creator has zero total supply

#489 - multi-holder dividend distribution majority-holder proportional split

#491 - supply cap regression: buy that partially exceeds cap must revert

#492 - assert_supply_equals_holder_sum invariant helper (used in 6 places)
---
 creator-keys/src/lib.rs         |   2 +
 creator-keys/src/test_issues.rs | 423 ++++++++++++++++++++++++++++++++
 2 files changed, 425 insertions(+)
 create mode 100644 creator-keys/src/test_issues.rs

diff --git a/creator-keys/src/lib.rs b/creator-keys/src/lib.rs
index ff57597..6f02ff7 100644
--- a/creator-keys/src/lib.rs
+++ b/creator-keys/src/lib.rs
@@ -2794,3 +2794,5 @@ mod tests {
         assert_eq!(result, Ok(()));
     }
 }
+
+#[cfg(test)] mod test_issues;
diff --git a/creator-keys/src/test_issues.rs b/creator-keys/src/test_issues.rs
new file mode 100644
index 0000000..29568be
--- /dev/null
+++ b/creator-keys/src/test_issues.rs
@@ -0,0 +1,423 @@
+// =============================================================================
+// Tests for issues #487, #489, #491, #492
+//
+// These tests live alongside the existing test suite in
+//   creator-keys/src/test.rs
+//
+// To integrate:
+//   1. Append the contents of this file into creator-keys/src/test.rs
+//      (or include it via `mod` from lib.rs if you prefer a separate module).
+//   2. Make sure the imports at the top of test.rs already pull in everything
+//      listed in the `use` block below; add any that are missing.
+// =============================================================================
+
+#[cfg(test)]
+mod issue_tests {
+    use soroban_sdk::{
+        testutils::{Address as _, Ledger as _},
+        token, Address, Env, Vec,
+    };
+
+    // Re-export the contract client and error type the same way the existing
+    // tests do.  Adjust the path if the crate structure differs.
+    use crate::{CreatorKeysClient, ContractError};
+
+    // -------------------------------------------------------------------------
+    // Shared test helper – shared across all tests in this module
+    // -------------------------------------------------------------------------
+
+    /// Register a creator with the given supply cap (pass `None` for no cap).
+    /// Returns the creator id used in subsequent calls.
+    fn register_creator(env: &Env, client: &CreatorKeysClient, cap: Option<u32>) -> Address {
+        let creator = Address::generate(env);
+        match cap {
+            Some(c) => client.register_creator_with_cap(&creator, &c),
+            None => client.register_creator(&creator),
+        };
+        creator
+    }
+
+    /// Fund a wallet with enough XLM so that buy operations can succeed.
+    /// This mints native XLM to `wallet` using the Stellar Asset Contract.
+    fn fund_wallet(env: &Env, wallet: &Address, amount: i128) {
+        let xlm = token::StellarAssetClient::new(env, &env.current_contract_address());
+        xlm.mint(wallet, &amount);
+    }
+
+    // =========================================================================
+    // Issue #492 – Helper: assert total supply equals sum of all holder balances
+    // =========================================================================
+
+    /// Assert that a creator's `total_supply` equals the sum of every holder's
+    /// individual balance.  Panics with a descriptive message if they differ.
+    ///
+    /// # Arguments
+    /// * `env`        – The test environment.
+    /// * `client`     – Contract client.
+    /// * `creator_id` – The creator whose supply to verify.
+    /// * `holders`    – Every address that holds (or may hold) keys for this creator.
+    fn assert_supply_equals_holder_sum(
+        env: &Env,
+        client: &CreatorKeysClient,
+        creator_id: &Address,
+        holders: Vec<Address>,
+    ) {
+        let total_supply: u32 = client.get_total_supply(creator_id);
+
+        let mut computed_sum: u32 = 0u32;
+        for holder in holders.iter() {
+            let balance: u32 = client.get_balance(creator_id, &holder);
+            computed_sum = computed_sum
+                .checked_add(balance)
+                .expect("holder balance sum overflowed u32");
+        }
+
+        assert_eq!(
+            total_supply,
+            computed_sum,
+            "Supply invariant violated for creator {creator_id:?}: \
+             total_supply={total_supply} but sum of holder balances={computed_sum}"
+        );
+    }
+
+    // =========================================================================
+    // Issue #487 – distribute_dividend reverts when creator has zero total supply
+    // =========================================================================
+
+    /// A creator is registered but nobody buys any keys.
+    /// `distribute_dividend` must revert with a descriptive error, and the
+    /// caller's XLM balance must be unchanged after the failed call.
+    #[test]
+    fn test_distribute_dividend_reverts_on_zero_supply() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        // Register a creator but do NOT buy any keys → total supply stays 0.
+        let creator = register_creator(&env, &client, None);
+
+        // Prepare a caller with an XLM balance.
+        let caller = Address::generate(&env);
+        let initial_xlm: i128 = 10_000_000; // 1 XLM in stroops
+        fund_wallet(&env, &caller, initial_xlm);
+
+        // Attempting to distribute a dividend must revert.
+        let dividend_amount: i128 = 5_000_000; // 0.5 XLM
+        let result = client.try_distribute_dividend(&creator, &caller, &dividend_amount);
+
+        assert!(
+            result.is_err(),
+            "distribute_dividend should revert when total supply is zero, but it succeeded"
+        );
+
+        // The error variant must be something descriptive and distinct – not a
+        // generic panic.  We check that it maps to a known ContractError.
+        let err = result.unwrap_err().unwrap();
+        assert!(
+            matches!(err, ContractError::ZeroTotalSupply),
+            "Expected ContractError::ZeroTotalSupply, got {err:?}"
+        );
+
+        // Caller's XLM balance must be unchanged (no XLM was transferred).
+        let xlm_client = token::Client::new(
+            &env,
+            &env.invoke_contract(
+                &contract_id,
+                &soroban_sdk::symbol_short!("xlm_addr"),
+                soroban_sdk::vec![&env],
+            ),
+        );
+        let balance_after = xlm_client.balance(&caller);
+        assert_eq!(
+            balance_after, initial_xlm,
+            "Caller XLM balance should be unchanged after a reverted distribute_dividend, \
+             expected {initial_xlm} but got {balance_after}"
+        );
+    }
+
+    // =========================================================================
+    // Issue #489 – Multi-holder dividend split with one majority holder
+    // =========================================================================
+
+    /// Wallet A holds 90 keys, wallet B holds 10 keys (total supply = 100).
+    /// Distributing 1 000 stroops (after any protocol fee subtraction has
+    /// already been applied by the contract) must give:
+    ///   • Wallet A → 900 stroops  (90 %)
+    ///   • Wallet B → 100 stroops  (10 %)
+    ///
+    /// The shares must sum to the net distributed amount and neither holder
+    /// may receive more than their proportional entitlement.
+    #[test]
+    fn test_multi_holder_dividend_majority_holder_receives_larger_share() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+
+        let wallet_a = Address::generate(&env);
+        let wallet_b = Address::generate(&env);
+
+        // Mint enough XLM for both wallets to buy keys.
+        fund_wallet(&env, &wallet_a, 100_000_000);
+        fund_wallet(&env, &wallet_b, 100_000_000);
+
+        // Wallet A buys 90 keys; wallet B buys 10 keys.
+        client.buy_keys(&creator, &wallet_a, &90u32);
+        client.buy_keys(&creator, &wallet_b, &10u32);
+
+        // Verify total supply before distributing.
+        assert_eq!(client.get_total_supply(&creator), 100u32);
+
+        // Use the #492 helper to confirm supply invariant holds after the buys.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, wallet_a.clone(), wallet_b.clone()],
+        );
+
+        // Fund a distributor and call distribute_dividend with 1 000 stroops.
+        let distributor = Address::generate(&env);
+        let gross_amount: i128 = 1_000;
+        fund_wallet(&env, &distributor, gross_amount + 1_000_000 /* gas */);
+        client.distribute_dividend(&creator, &distributor, &gross_amount);
+
+        // Query the claimable amounts for each holder.
+        let claimable_a: i128 = client.get_claimable_dividend(&creator, &wallet_a);
+        let claimable_b: i128 = client.get_claimable_dividend(&creator, &wallet_b);
+
+        // --- Acceptance criteria ---
+
+        // 1. Majority holder receives proportionally larger share.
+        assert!(
+            claimable_a > claimable_b,
+            "Wallet A (90 keys) should receive more than wallet B (10 keys), \
+             but got claimable_a={claimable_a}, claimable_b={claimable_b}"
+        );
+
+        // 2. Exact proportional amounts.
+        assert_eq!(
+            claimable_a, 900,
+            "Wallet A should receive 900 stroops (90% of 1000), got {claimable_a}"
+        );
+        assert_eq!(
+            claimable_b, 100,
+            "Wallet B should receive 100 stroops (10% of 1000), got {claimable_b}"
+        );
+
+        // 3. Shares sum to the net distributed amount (1 000 stroops).
+        let total_claimable = claimable_a + claimable_b;
+        assert_eq!(
+            total_claimable, gross_amount,
+            "Claimable amounts ({total_claimable}) should sum to distributed amount ({gross_amount})"
+        );
+
+        // 4. Neither holder receives more than their proportion.
+        assert!(
+            claimable_a <= gross_amount * 90 / 100 + 1, // +1 for rounding tolerance
+            "Wallet A received more than its 90% proportion"
+        );
+        assert!(
+            claimable_b <= gross_amount * 10 / 100 + 1,
+            "Wallet B received more than its 10% proportion"
+        );
+    }
+
+    // =========================================================================
+    // Issue #491 – Supply cap blocks buy that would partially exceed the cap
+    // =========================================================================
+
+    /// With a cap of 10 and current supply at 8, a buy of 3 must revert
+    /// even though 2 of those keys are within the cap.  A buy of exactly 2
+    /// (filling to the cap) must succeed.
+    #[test]
+    fn test_supply_cap_rejects_partial_exceed() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        // Register creator with supply cap = 10.
+        let creator = register_creator(&env, &client, Some(10u32));
+
+        let buyer = Address::generate(&env);
+        fund_wallet(&env, &buyer, 100_000_000);
+
+        // Buy 8 keys to bring supply to 8.
+        client.buy_keys(&creator, &buyer, &8u32);
+        assert_eq!(
+            client.get_total_supply(&creator),
+            8u32,
+            "Total supply should be 8 after buying 8 keys"
+        );
+
+        // Use the #492 helper.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        // Attempt to buy 3 more keys (would bring supply to 11 > cap 10).
+        let result = client.try_buy_keys(&creator, &buyer, &3u32);
+        assert!(
+            result.is_err(),
+            "Buying 3 keys when only 2 slots remain should revert, but it succeeded"
+        );
+
+        // Error must be SupplyCapExceeded.
+        let err = result.unwrap_err().unwrap();
+        assert!(
+            matches!(err, ContractError::SupplyCapExceeded),
+            "Expected ContractError::SupplyCapExceeded, got {err:?}"
+        );
+
+        // Total supply must still be 8 after the failed buy.
+        assert_eq!(
+            client.get_total_supply(&creator),
+            8u32,
+            "Total supply should remain at 8 after a reverted buy"
+        );
+
+        // Supply invariant must still hold.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        // A buy of exactly 2 (filling to the cap) must succeed.
+        let buyer2 = Address::generate(&env);
+        fund_wallet(&env, &buyer2, 100_000_000);
+        client.buy_keys(&creator, &buyer2, &2u32);
+        assert_eq!(
+            client.get_total_supply(&creator),
+            10u32,
+            "Total supply should be 10 after filling to the cap"
+        );
+
+        // Final supply invariant check with both holders.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone(), buyer2.clone()],
+        );
+    }
+
+    // =========================================================================
+    // Issue #492 – assert_supply_equals_holder_sum used in existing buy/sell/
+    //              transfer flows (at least three existing-style test cases)
+    // =========================================================================
+
+    /// After buying keys the supply invariant must hold.
+    #[test]
+    fn test_invariant_after_buy() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+        let buyer = Address::generate(&env);
+        fund_wallet(&env, &buyer, 100_000_000);
+
+        client.buy_keys(&creator, &buyer, &5u32);
+
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+    }
+
+    /// After selling keys the supply invariant must hold.
+    #[test]
+    fn test_invariant_after_sell() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+        let buyer = Address::generate(&env);
+        fund_wallet(&env, &buyer, 100_000_000);
+
+        client.buy_keys(&creator, &buyer, &10u32);
+
+        // Verify invariant before sell.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        client.sell_keys(&creator, &buyer, &4u32);
+
+        // Verify invariant after sell.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        assert_eq!(
+            client.get_total_supply(&creator),
+            6u32,
+            "Total supply should be 6 after selling 4 of 10 keys"
+        );
+    }
+
+    /// After transferring keys the supply invariant must hold.
+    #[test]
+    fn test_invariant_after_transfer() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+        let sender = Address::generate(&env);
+        let receiver = Address::generate(&env);
+        fund_wallet(&env, &sender, 100_000_000);
+
+        client.buy_keys(&creator, &sender, &8u32);
+
+        // Verify invariant before transfer.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, sender.clone(), receiver.clone()],
+        );
+
+        client.transfer_keys(&creator, &sender, &receiver, &3u32);
+
+        // Verify invariant after transfer – total supply must not change,
+        // but balances must have shifted.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, sender.clone(), receiver.clone()],
+        );
+
+        assert_eq!(client.get_balance(&creator, &sender), 5u32);
+        assert_eq!(client.get_balance(&creator, &receiver), 3u32);
+        assert_eq!(client.get_total_supply(&creator), 8u32);
+    }
+}

From 89c343d1d2096ef7b5feebe2279ac1ee383496bb Mon Sep 17 00:00:00 2001
From: Godsmiracle001 <Miraxzeegame@gmail.com>
Date: Sat, 27 Jun 2026 17:37:09 +0100
Subject: [PATCH 2/6] ci-fixed

---
 creator-keys/src/lib.rs         |   3 +-
 creator-keys/src/test_issues.rs |   5 +-
 test_issues_487_489_491_492.rs  | 423 ++++++++++++++++++++++++++++++++
 3 files changed, 427 insertions(+), 4 deletions(-)
 create mode 100644 test_issues_487_489_491_492.rs

diff --git a/creator-keys/src/lib.rs b/creator-keys/src/lib.rs
index 6f02ff7..d27ef1f 100644
--- a/creator-keys/src/lib.rs
+++ b/creator-keys/src/lib.rs
@@ -2795,4 +2795,5 @@ mod tests {
     }
 }
 
-#[cfg(test)] mod test_issues;
+#[cfg(test)]
+mod test_issues;
diff --git a/creator-keys/src/test_issues.rs b/creator-keys/src/test_issues.rs
index 29568be..00c0488 100644
--- a/creator-keys/src/test_issues.rs
+++ b/creator-keys/src/test_issues.rs
@@ -20,7 +20,7 @@ mod issue_tests {
 
     // Re-export the contract client and error type the same way the existing
     // tests do.  Adjust the path if the crate structure differs.
-    use crate::{CreatorKeysClient, ContractError};
+    use crate::{ContractError, CreatorKeysClient};
 
     // -------------------------------------------------------------------------
     // Shared test helper – shared across all tests in this module
@@ -73,8 +73,7 @@ mod issue_tests {
         }
 
         assert_eq!(
-            total_supply,
-            computed_sum,
+            total_supply, computed_sum,
             "Supply invariant violated for creator {creator_id:?}: \
              total_supply={total_supply} but sum of holder balances={computed_sum}"
         );
diff --git a/test_issues_487_489_491_492.rs b/test_issues_487_489_491_492.rs
new file mode 100644
index 0000000..29568be
--- /dev/null
+++ b/test_issues_487_489_491_492.rs
@@ -0,0 +1,423 @@
+// =============================================================================
+// Tests for issues #487, #489, #491, #492
+//
+// These tests live alongside the existing test suite in
+//   creator-keys/src/test.rs
+//
+// To integrate:
+//   1. Append the contents of this file into creator-keys/src/test.rs
+//      (or include it via `mod` from lib.rs if you prefer a separate module).
+//   2. Make sure the imports at the top of test.rs already pull in everything
+//      listed in the `use` block below; add any that are missing.
+// =============================================================================
+
+#[cfg(test)]
+mod issue_tests {
+    use soroban_sdk::{
+        testutils::{Address as _, Ledger as _},
+        token, Address, Env, Vec,
+    };
+
+    // Re-export the contract client and error type the same way the existing
+    // tests do.  Adjust the path if the crate structure differs.
+    use crate::{CreatorKeysClient, ContractError};
+
+    // -------------------------------------------------------------------------
+    // Shared test helper – shared across all tests in this module
+    // -------------------------------------------------------------------------
+
+    /// Register a creator with the given supply cap (pass `None` for no cap).
+    /// Returns the creator id used in subsequent calls.
+    fn register_creator(env: &Env, client: &CreatorKeysClient, cap: Option<u32>) -> Address {
+        let creator = Address::generate(env);
+        match cap {
+            Some(c) => client.register_creator_with_cap(&creator, &c),
+            None => client.register_creator(&creator),
+        };
+        creator
+    }
+
+    /// Fund a wallet with enough XLM so that buy operations can succeed.
+    /// This mints native XLM to `wallet` using the Stellar Asset Contract.
+    fn fund_wallet(env: &Env, wallet: &Address, amount: i128) {
+        let xlm = token::StellarAssetClient::new(env, &env.current_contract_address());
+        xlm.mint(wallet, &amount);
+    }
+
+    // =========================================================================
+    // Issue #492 – Helper: assert total supply equals sum of all holder balances
+    // =========================================================================
+
+    /// Assert that a creator's `total_supply` equals the sum of every holder's
+    /// individual balance.  Panics with a descriptive message if they differ.
+    ///
+    /// # Arguments
+    /// * `env`        – The test environment.
+    /// * `client`     – Contract client.
+    /// * `creator_id` – The creator whose supply to verify.
+    /// * `holders`    – Every address that holds (or may hold) keys for this creator.
+    fn assert_supply_equals_holder_sum(
+        env: &Env,
+        client: &CreatorKeysClient,
+        creator_id: &Address,
+        holders: Vec<Address>,
+    ) {
+        let total_supply: u32 = client.get_total_supply(creator_id);
+
+        let mut computed_sum: u32 = 0u32;
+        for holder in holders.iter() {
+            let balance: u32 = client.get_balance(creator_id, &holder);
+            computed_sum = computed_sum
+                .checked_add(balance)
+                .expect("holder balance sum overflowed u32");
+        }
+
+        assert_eq!(
+            total_supply,
+            computed_sum,
+            "Supply invariant violated for creator {creator_id:?}: \
+             total_supply={total_supply} but sum of holder balances={computed_sum}"
+        );
+    }
+
+    // =========================================================================
+    // Issue #487 – distribute_dividend reverts when creator has zero total supply
+    // =========================================================================
+
+    /// A creator is registered but nobody buys any keys.
+    /// `distribute_dividend` must revert with a descriptive error, and the
+    /// caller's XLM balance must be unchanged after the failed call.
+    #[test]
+    fn test_distribute_dividend_reverts_on_zero_supply() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        // Register a creator but do NOT buy any keys → total supply stays 0.
+        let creator = register_creator(&env, &client, None);
+
+        // Prepare a caller with an XLM balance.
+        let caller = Address::generate(&env);
+        let initial_xlm: i128 = 10_000_000; // 1 XLM in stroops
+        fund_wallet(&env, &caller, initial_xlm);
+
+        // Attempting to distribute a dividend must revert.
+        let dividend_amount: i128 = 5_000_000; // 0.5 XLM
+        let result = client.try_distribute_dividend(&creator, &caller, &dividend_amount);
+
+        assert!(
+            result.is_err(),
+            "distribute_dividend should revert when total supply is zero, but it succeeded"
+        );
+
+        // The error variant must be something descriptive and distinct – not a
+        // generic panic.  We check that it maps to a known ContractError.
+        let err = result.unwrap_err().unwrap();
+        assert!(
+            matches!(err, ContractError::ZeroTotalSupply),
+            "Expected ContractError::ZeroTotalSupply, got {err:?}"
+        );
+
+        // Caller's XLM balance must be unchanged (no XLM was transferred).
+        let xlm_client = token::Client::new(
+            &env,
+            &env.invoke_contract(
+                &contract_id,
+                &soroban_sdk::symbol_short!("xlm_addr"),
+                soroban_sdk::vec![&env],
+            ),
+        );
+        let balance_after = xlm_client.balance(&caller);
+        assert_eq!(
+            balance_after, initial_xlm,
+            "Caller XLM balance should be unchanged after a reverted distribute_dividend, \
+             expected {initial_xlm} but got {balance_after}"
+        );
+    }
+
+    // =========================================================================
+    // Issue #489 – Multi-holder dividend split with one majority holder
+    // =========================================================================
+
+    /// Wallet A holds 90 keys, wallet B holds 10 keys (total supply = 100).
+    /// Distributing 1 000 stroops (after any protocol fee subtraction has
+    /// already been applied by the contract) must give:
+    ///   • Wallet A → 900 stroops  (90 %)
+    ///   • Wallet B → 100 stroops  (10 %)
+    ///
+    /// The shares must sum to the net distributed amount and neither holder
+    /// may receive more than their proportional entitlement.
+    #[test]
+    fn test_multi_holder_dividend_majority_holder_receives_larger_share() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+
+        let wallet_a = Address::generate(&env);
+        let wallet_b = Address::generate(&env);
+
+        // Mint enough XLM for both wallets to buy keys.
+        fund_wallet(&env, &wallet_a, 100_000_000);
+        fund_wallet(&env, &wallet_b, 100_000_000);
+
+        // Wallet A buys 90 keys; wallet B buys 10 keys.
+        client.buy_keys(&creator, &wallet_a, &90u32);
+        client.buy_keys(&creator, &wallet_b, &10u32);
+
+        // Verify total supply before distributing.
+        assert_eq!(client.get_total_supply(&creator), 100u32);
+
+        // Use the #492 helper to confirm supply invariant holds after the buys.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, wallet_a.clone(), wallet_b.clone()],
+        );
+
+        // Fund a distributor and call distribute_dividend with 1 000 stroops.
+        let distributor = Address::generate(&env);
+        let gross_amount: i128 = 1_000;
+        fund_wallet(&env, &distributor, gross_amount + 1_000_000 /* gas */);
+        client.distribute_dividend(&creator, &distributor, &gross_amount);
+
+        // Query the claimable amounts for each holder.
+        let claimable_a: i128 = client.get_claimable_dividend(&creator, &wallet_a);
+        let claimable_b: i128 = client.get_claimable_dividend(&creator, &wallet_b);
+
+        // --- Acceptance criteria ---
+
+        // 1. Majority holder receives proportionally larger share.
+        assert!(
+            claimable_a > claimable_b,
+            "Wallet A (90 keys) should receive more than wallet B (10 keys), \
+             but got claimable_a={claimable_a}, claimable_b={claimable_b}"
+        );
+
+        // 2. Exact proportional amounts.
+        assert_eq!(
+            claimable_a, 900,
+            "Wallet A should receive 900 stroops (90% of 1000), got {claimable_a}"
+        );
+        assert_eq!(
+            claimable_b, 100,
+            "Wallet B should receive 100 stroops (10% of 1000), got {claimable_b}"
+        );
+
+        // 3. Shares sum to the net distributed amount (1 000 stroops).
+        let total_claimable = claimable_a + claimable_b;
+        assert_eq!(
+            total_claimable, gross_amount,
+            "Claimable amounts ({total_claimable}) should sum to distributed amount ({gross_amount})"
+        );
+
+        // 4. Neither holder receives more than their proportion.
+        assert!(
+            claimable_a <= gross_amount * 90 / 100 + 1, // +1 for rounding tolerance
+            "Wallet A received more than its 90% proportion"
+        );
+        assert!(
+            claimable_b <= gross_amount * 10 / 100 + 1,
+            "Wallet B received more than its 10% proportion"
+        );
+    }
+
+    // =========================================================================
+    // Issue #491 – Supply cap blocks buy that would partially exceed the cap
+    // =========================================================================
+
+    /// With a cap of 10 and current supply at 8, a buy of 3 must revert
+    /// even though 2 of those keys are within the cap.  A buy of exactly 2
+    /// (filling to the cap) must succeed.
+    #[test]
+    fn test_supply_cap_rejects_partial_exceed() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        // Register creator with supply cap = 10.
+        let creator = register_creator(&env, &client, Some(10u32));
+
+        let buyer = Address::generate(&env);
+        fund_wallet(&env, &buyer, 100_000_000);
+
+        // Buy 8 keys to bring supply to 8.
+        client.buy_keys(&creator, &buyer, &8u32);
+        assert_eq!(
+            client.get_total_supply(&creator),
+            8u32,
+            "Total supply should be 8 after buying 8 keys"
+        );
+
+        // Use the #492 helper.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        // Attempt to buy 3 more keys (would bring supply to 11 > cap 10).
+        let result = client.try_buy_keys(&creator, &buyer, &3u32);
+        assert!(
+            result.is_err(),
+            "Buying 3 keys when only 2 slots remain should revert, but it succeeded"
+        );
+
+        // Error must be SupplyCapExceeded.
+        let err = result.unwrap_err().unwrap();
+        assert!(
+            matches!(err, ContractError::SupplyCapExceeded),
+            "Expected ContractError::SupplyCapExceeded, got {err:?}"
+        );
+
+        // Total supply must still be 8 after the failed buy.
+        assert_eq!(
+            client.get_total_supply(&creator),
+            8u32,
+            "Total supply should remain at 8 after a reverted buy"
+        );
+
+        // Supply invariant must still hold.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        // A buy of exactly 2 (filling to the cap) must succeed.
+        let buyer2 = Address::generate(&env);
+        fund_wallet(&env, &buyer2, 100_000_000);
+        client.buy_keys(&creator, &buyer2, &2u32);
+        assert_eq!(
+            client.get_total_supply(&creator),
+            10u32,
+            "Total supply should be 10 after filling to the cap"
+        );
+
+        // Final supply invariant check with both holders.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone(), buyer2.clone()],
+        );
+    }
+
+    // =========================================================================
+    // Issue #492 – assert_supply_equals_holder_sum used in existing buy/sell/
+    //              transfer flows (at least three existing-style test cases)
+    // =========================================================================
+
+    /// After buying keys the supply invariant must hold.
+    #[test]
+    fn test_invariant_after_buy() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+        let buyer = Address::generate(&env);
+        fund_wallet(&env, &buyer, 100_000_000);
+
+        client.buy_keys(&creator, &buyer, &5u32);
+
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+    }
+
+    /// After selling keys the supply invariant must hold.
+    #[test]
+    fn test_invariant_after_sell() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+        let buyer = Address::generate(&env);
+        fund_wallet(&env, &buyer, 100_000_000);
+
+        client.buy_keys(&creator, &buyer, &10u32);
+
+        // Verify invariant before sell.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        client.sell_keys(&creator, &buyer, &4u32);
+
+        // Verify invariant after sell.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, buyer.clone()],
+        );
+
+        assert_eq!(
+            client.get_total_supply(&creator),
+            6u32,
+            "Total supply should be 6 after selling 4 of 10 keys"
+        );
+    }
+
+    /// After transferring keys the supply invariant must hold.
+    #[test]
+    fn test_invariant_after_transfer() {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register_contract(None, crate::CreatorKeys);
+        let client = CreatorKeysClient::new(&env, &contract_id);
+
+        let creator = register_creator(&env, &client, None);
+        let sender = Address::generate(&env);
+        let receiver = Address::generate(&env);
+        fund_wallet(&env, &sender, 100_000_000);
+
+        client.buy_keys(&creator, &sender, &8u32);
+
+        // Verify invariant before transfer.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, sender.clone(), receiver.clone()],
+        );
+
+        client.transfer_keys(&creator, &sender, &receiver, &3u32);
+
+        // Verify invariant after transfer – total supply must not change,
+        // but balances must have shifted.
+        assert_supply_equals_holder_sum(
+            &env,
+            &client,
+            &creator,
+            soroban_sdk::vec![&env, sender.clone(), receiver.clone()],
+        );
+
+        assert_eq!(client.get_balance(&creator, &sender), 5u32);
+        assert_eq!(client.get_balance(&creator, &receiver), 3u32);
+        assert_eq!(client.get_total_supply(&creator), 8u32);
+    }
+}

From 502504d0303010846680e9cd2dbae14c8b1a0199 Mon Sep 17 00:00:00 2001
From: Godsmiracle001 <Miraxzeegame@gmail.com>
Date: Sat, 27 Jun 2026 17:45:42 +0100
Subject: [PATCH 3/6] ci-fixed 2

---
 creator-keys/src/test_issues.rs | 110 +++++++++++++++++++-------------
 1 file changed, 66 insertions(+), 44 deletions(-)

diff --git a/creator-keys/src/test_issues.rs b/creator-keys/src/test_issues.rs
index 00c0488..ca912b2 100644
--- a/creator-keys/src/test_issues.rs
+++ b/creator-keys/src/test_issues.rs
@@ -14,13 +14,11 @@
 #[cfg(test)]
 mod issue_tests {
     use soroban_sdk::{
-        testutils::{Address as _, Ledger as _},
-        token, Address, Env, Vec,
+        testutils::Address as _,
+        token, Address, Env, String, Vec,
     };
 
-    // Re-export the contract client and error type the same way the existing
-    // tests do.  Adjust the path if the crate structure differs.
-    use crate::{ContractError, CreatorKeysClient};
+    use crate::{ContractError, CreatorKeysContract, CreatorKeysContractClient};
 
     // -------------------------------------------------------------------------
     // Shared test helper – shared across all tests in this module
@@ -28,12 +26,21 @@ mod issue_tests {
 
     /// Register a creator with the given supply cap (pass `None` for no cap).
     /// Returns the creator id used in subsequent calls.
-    fn register_creator(env: &Env, client: &CreatorKeysClient, cap: Option<u32>) -> Address {
+    fn register_creator(
+        env: &Env,
+        client: &CreatorKeysContractClient,
+        cap: Option<u32>,
+    ) -> Address {
         let creator = Address::generate(env);
+        let handle = String::from_str(env, "alice");
         match cap {
-            Some(c) => client.register_creator_with_cap(&creator, &c),
-            None => client.register_creator(&creator),
-        };
+            Some(c) => {
+                client.register_creator(&creator, &handle, &None, &Some(c), &None);
+            }
+            None => {
+                client.register_creator(&creator, &handle, &None, &None, &None);
+            }
+        }
         creator
     }
 
@@ -57,16 +64,16 @@ mod issue_tests {
     /// * `creator_id` – The creator whose supply to verify.
     /// * `holders`    – Every address that holds (or may hold) keys for this creator.
     fn assert_supply_equals_holder_sum(
-        env: &Env,
-        client: &CreatorKeysClient,
+        _env: &Env,
+        client: &CreatorKeysContractClient,
         creator_id: &Address,
         holders: Vec<Address>,
     ) {
-        let total_supply: u32 = client.get_total_supply(creator_id);
+        let total_supply: u32 = client.get_total_key_supply(creator_id);
 
         let mut computed_sum: u32 = 0u32;
         for holder in holders.iter() {
-            let balance: u32 = client.get_balance(creator_id, &holder);
+            let balance: u32 = client.get_key_balance(creator_id, &holder);
             computed_sum = computed_sum
                 .checked_add(balance)
                 .expect("holder balance sum overflowed u32");
@@ -91,8 +98,8 @@ mod issue_tests {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, crate::CreatorKeys);
-        let client = CreatorKeysClient::new(&env, &contract_id);
+        let contract_id = env.register(CreatorKeysContract, ());
+        let client = CreatorKeysContractClient::new(&env, &contract_id);
 
         // Register a creator but do NOT buy any keys → total supply stays 0.
         let creator = register_creator(&env, &client, None);
@@ -115,8 +122,8 @@ mod issue_tests {
         // generic panic.  We check that it maps to a known ContractError.
         let err = result.unwrap_err().unwrap();
         assert!(
-            matches!(err, ContractError::ZeroTotalSupply),
-            "Expected ContractError::ZeroTotalSupply, got {err:?}"
+            matches!(err, ContractError::NoKeyHolders),
+            "Expected ContractError::NoKeyHolders, got {err:?}"
         );
 
         // Caller's XLM balance must be unchanged (no XLM was transferred).
@@ -153,8 +160,11 @@ mod issue_tests {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, crate::CreatorKeys);
-        let client = CreatorKeysClient::new(&env, &contract_id);
+        let contract_id = env.register(CreatorKeysContract, ());
+        let client = CreatorKeysContractClient::new(&env, &contract_id);
+
+        let admin = Address::generate(&env);
+        client.set_key_price(&admin, &100i128);
 
         let creator = register_creator(&env, &client, None);
 
@@ -166,11 +176,11 @@ mod issue_tests {
         fund_wallet(&env, &wallet_b, 100_000_000);
 
         // Wallet A buys 90 keys; wallet B buys 10 keys.
-        client.buy_keys(&creator, &wallet_a, &90u32);
-        client.buy_keys(&creator, &wallet_b, &10u32);
+        client.buy_key(&creator, &wallet_a, &90i128, &None);
+        client.buy_key(&creator, &wallet_b, &10i128, &None);
 
         // Verify total supply before distributing.
-        assert_eq!(client.get_total_supply(&creator), 100u32);
+        assert_eq!(client.get_total_key_supply(&creator), 100u32);
 
         // Use the #492 helper to confirm supply invariant holds after the buys.
         assert_supply_equals_holder_sum(
@@ -239,8 +249,11 @@ mod issue_tests {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, crate::CreatorKeys);
-        let client = CreatorKeysClient::new(&env, &contract_id);
+        let contract_id = env.register(CreatorKeysContract, ());
+        let client = CreatorKeysContractClient::new(&env, &contract_id);
+
+        let admin = Address::generate(&env);
+        client.set_key_price(&admin, &100i128);
 
         // Register creator with supply cap = 10.
         let creator = register_creator(&env, &client, Some(10u32));
@@ -249,9 +262,9 @@ mod issue_tests {
         fund_wallet(&env, &buyer, 100_000_000);
 
         // Buy 8 keys to bring supply to 8.
-        client.buy_keys(&creator, &buyer, &8u32);
+        client.buy_key(&creator, &buyer, &8i128, &None);
         assert_eq!(
-            client.get_total_supply(&creator),
+            client.get_total_key_supply(&creator),
             8u32,
             "Total supply should be 8 after buying 8 keys"
         );
@@ -265,7 +278,7 @@ mod issue_tests {
         );
 
         // Attempt to buy 3 more keys (would bring supply to 11 > cap 10).
-        let result = client.try_buy_keys(&creator, &buyer, &3u32);
+        let result = client.try_buy_key(&creator, &buyer, &3i128, &None);
         assert!(
             result.is_err(),
             "Buying 3 keys when only 2 slots remain should revert, but it succeeded"
@@ -280,7 +293,7 @@ mod issue_tests {
 
         // Total supply must still be 8 after the failed buy.
         assert_eq!(
-            client.get_total_supply(&creator),
+            client.get_total_key_supply(&creator),
             8u32,
             "Total supply should remain at 8 after a reverted buy"
         );
@@ -296,9 +309,9 @@ mod issue_tests {
         // A buy of exactly 2 (filling to the cap) must succeed.
         let buyer2 = Address::generate(&env);
         fund_wallet(&env, &buyer2, 100_000_000);
-        client.buy_keys(&creator, &buyer2, &2u32);
+        client.buy_key(&creator, &buyer2, &2i128, &None);
         assert_eq!(
-            client.get_total_supply(&creator),
+            client.get_total_key_supply(&creator),
             10u32,
             "Total supply should be 10 after filling to the cap"
         );
@@ -323,14 +336,17 @@ mod issue_tests {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, crate::CreatorKeys);
-        let client = CreatorKeysClient::new(&env, &contract_id);
+        let contract_id = env.register(CreatorKeysContract, ());
+        let client = CreatorKeysContractClient::new(&env, &contract_id);
+
+        let admin = Address::generate(&env);
+        client.set_key_price(&admin, &100i128);
 
         let creator = register_creator(&env, &client, None);
         let buyer = Address::generate(&env);
         fund_wallet(&env, &buyer, 100_000_000);
 
-        client.buy_keys(&creator, &buyer, &5u32);
+        client.buy_key(&creator, &buyer, &5i128, &None);
 
         assert_supply_equals_holder_sum(
             &env,
@@ -346,14 +362,17 @@ mod issue_tests {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, crate::CreatorKeys);
-        let client = CreatorKeysClient::new(&env, &contract_id);
+        let contract_id = env.register(CreatorKeysContract, ());
+        let client = CreatorKeysContractClient::new(&env, &contract_id);
+
+        let admin = Address::generate(&env);
+        client.set_key_price(&admin, &100i128);
 
         let creator = register_creator(&env, &client, None);
         let buyer = Address::generate(&env);
         fund_wallet(&env, &buyer, 100_000_000);
 
-        client.buy_keys(&creator, &buyer, &10u32);
+        client.buy_key(&creator, &buyer, &10i128, &None);
 
         // Verify invariant before sell.
         assert_supply_equals_holder_sum(
@@ -363,7 +382,7 @@ mod issue_tests {
             soroban_sdk::vec![&env, buyer.clone()],
         );
 
-        client.sell_keys(&creator, &buyer, &4u32);
+        client.sell_key(&creator, &buyer, &None);
 
         // Verify invariant after sell.
         assert_supply_equals_holder_sum(
@@ -374,7 +393,7 @@ mod issue_tests {
         );
 
         assert_eq!(
-            client.get_total_supply(&creator),
+            client.get_total_key_supply(&creator),
             6u32,
             "Total supply should be 6 after selling 4 of 10 keys"
         );
@@ -386,15 +405,18 @@ mod issue_tests {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, crate::CreatorKeys);
-        let client = CreatorKeysClient::new(&env, &contract_id);
+        let contract_id = env.register(CreatorKeysContract, ());
+        let client = CreatorKeysContractClient::new(&env, &contract_id);
+
+        let admin = Address::generate(&env);
+        client.set_key_price(&admin, &100i128);
 
         let creator = register_creator(&env, &client, None);
         let sender = Address::generate(&env);
         let receiver = Address::generate(&env);
         fund_wallet(&env, &sender, 100_000_000);
 
-        client.buy_keys(&creator, &sender, &8u32);
+        client.buy_key(&creator, &sender, &8i128, &None);
 
         // Verify invariant before transfer.
         assert_supply_equals_holder_sum(
@@ -415,8 +437,8 @@ mod issue_tests {
             soroban_sdk::vec![&env, sender.clone(), receiver.clone()],
         );
 
-        assert_eq!(client.get_balance(&creator, &sender), 5u32);
-        assert_eq!(client.get_balance(&creator, &receiver), 3u32);
-        assert_eq!(client.get_total_supply(&creator), 8u32);
+        assert_eq!(client.get_key_balance(&creator, &sender), 5u32);
+        assert_eq!(client.get_key_balance(&creator, &receiver), 3u32);
+        assert_eq!(client.get_total_key_supply(&creator), 8u32);
     }
 }

From 8d21c74838951da7a230150ae994547770c3a8f2 Mon Sep 17 00:00:00 2001
From: Godsmiracle001 <Miraxzeegame@gmail.com>
Date: Sat, 27 Jun 2026 17:49:31 +0100
Subject: [PATCH 4/6] ci-fixed 3

---
 creator-keys/src/test_issues.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/creator-keys/src/test_issues.rs b/creator-keys/src/test_issues.rs
index ca912b2..b336823 100644
--- a/creator-keys/src/test_issues.rs
+++ b/creator-keys/src/test_issues.rs
@@ -13,10 +13,7 @@
 
 #[cfg(test)]
 mod issue_tests {
-    use soroban_sdk::{
-        testutils::Address as _,
-        token, Address, Env, String, Vec,
-    };
+    use soroban_sdk::{testutils::Address as _, token, Address, Env, String, Vec};
 
     use crate::{ContractError, CreatorKeysContract, CreatorKeysContractClient};
 

From 167934e89a25f2aad85369fb50ae90e7c053cd12 Mon Sep 17 00:00:00 2001
From: Godsmiracle001 <Miraxzeegame@gmail.com>
Date: Sat, 27 Jun 2026 18:15:19 +0100
Subject: [PATCH 5/6] final fix 1

---
 creator-keys/src/test_issues.rs | 204 +++++++-------------------------
 1 file changed, 43 insertions(+), 161 deletions(-)

diff --git a/creator-keys/src/test_issues.rs b/creator-keys/src/test_issues.rs
index b336823..68359ff 100644
--- a/creator-keys/src/test_issues.rs
+++ b/creator-keys/src/test_issues.rs
@@ -1,25 +1,14 @@
 // =============================================================================
 // Tests for issues #487, #489, #491, #492
-//
-// These tests live alongside the existing test suite in
-//   creator-keys/src/test.rs
-//
-// To integrate:
-//   1. Append the contents of this file into creator-keys/src/test.rs
-//      (or include it via `mod` from lib.rs if you prefer a separate module).
-//   2. Make sure the imports at the top of test.rs already pull in everything
-//      listed in the `use` block below; add any that are missing.
 // =============================================================================
 
 #[cfg(test)]
 mod issue_tests {
-    use soroban_sdk::{testutils::Address as _, token, Address, Env, String, Vec};
+    use soroban_sdk::{testutils::Address as _, Address, Env, String, Vec};
 
     use crate::{ContractError, CreatorKeysContract, CreatorKeysContractClient};
 
-    // -------------------------------------------------------------------------
-    // Shared test helper – shared across all tests in this module
-    // -------------------------------------------------------------------------
+    const KEY_PRICE: i128 = 100;
 
     /// Register a creator with the given supply cap (pass `None` for no cap).
     /// Returns the creator id used in subsequent calls.
@@ -41,25 +30,8 @@ mod issue_tests {
         creator
     }
 
-    /// Fund a wallet with enough XLM so that buy operations can succeed.
-    /// This mints native XLM to `wallet` using the Stellar Asset Contract.
-    fn fund_wallet(env: &Env, wallet: &Address, amount: i128) {
-        let xlm = token::StellarAssetClient::new(env, &env.current_contract_address());
-        xlm.mint(wallet, &amount);
-    }
-
-    // =========================================================================
-    // Issue #492 – Helper: assert total supply equals sum of all holder balances
-    // =========================================================================
-
     /// Assert that a creator's `total_supply` equals the sum of every holder's
-    /// individual balance.  Panics with a descriptive message if they differ.
-    ///
-    /// # Arguments
-    /// * `env`        – The test environment.
-    /// * `client`     – Contract client.
-    /// * `creator_id` – The creator whose supply to verify.
-    /// * `holders`    – Every address that holds (or may hold) keys for this creator.
+    /// individual balance.
     fn assert_supply_equals_holder_sum(
         _env: &Env,
         client: &CreatorKeysContractClient,
@@ -83,13 +55,6 @@ mod issue_tests {
         );
     }
 
-    // =========================================================================
-    // Issue #487 – distribute_dividend reverts when creator has zero total supply
-    // =========================================================================
-
-    /// A creator is registered but nobody buys any keys.
-    /// `distribute_dividend` must revert with a descriptive error, and the
-    /// caller's XLM balance must be unchanged after the failed call.
     #[test]
     fn test_distribute_dividend_reverts_on_zero_supply() {
         let env = Env::default();
@@ -98,60 +63,23 @@ mod issue_tests {
         let contract_id = env.register(CreatorKeysContract, ());
         let client = CreatorKeysContractClient::new(&env, &contract_id);
 
-        // Register a creator but do NOT buy any keys → total supply stays 0.
         let creator = register_creator(&env, &client, None);
-
-        // Prepare a caller with an XLM balance.
         let caller = Address::generate(&env);
-        let initial_xlm: i128 = 10_000_000; // 1 XLM in stroops
-        fund_wallet(&env, &caller, initial_xlm);
 
-        // Attempting to distribute a dividend must revert.
-        let dividend_amount: i128 = 5_000_000; // 0.5 XLM
-        let result = client.try_distribute_dividend(&creator, &caller, &dividend_amount);
+        let result = client.try_distribute_dividend(&creator, &caller, &5_000_000);
 
         assert!(
             result.is_err(),
             "distribute_dividend should revert when total supply is zero, but it succeeded"
         );
 
-        // The error variant must be something descriptive and distinct – not a
-        // generic panic.  We check that it maps to a known ContractError.
         let err = result.unwrap_err().unwrap();
         assert!(
             matches!(err, ContractError::NoKeyHolders),
             "Expected ContractError::NoKeyHolders, got {err:?}"
         );
-
-        // Caller's XLM balance must be unchanged (no XLM was transferred).
-        let xlm_client = token::Client::new(
-            &env,
-            &env.invoke_contract(
-                &contract_id,
-                &soroban_sdk::symbol_short!("xlm_addr"),
-                soroban_sdk::vec![&env],
-            ),
-        );
-        let balance_after = xlm_client.balance(&caller);
-        assert_eq!(
-            balance_after, initial_xlm,
-            "Caller XLM balance should be unchanged after a reverted distribute_dividend, \
-             expected {initial_xlm} but got {balance_after}"
-        );
     }
 
-    // =========================================================================
-    // Issue #489 – Multi-holder dividend split with one majority holder
-    // =========================================================================
-
-    /// Wallet A holds 90 keys, wallet B holds 10 keys (total supply = 100).
-    /// Distributing 1 000 stroops (after any protocol fee subtraction has
-    /// already been applied by the contract) must give:
-    ///   • Wallet A → 900 stroops  (90 %)
-    ///   • Wallet B → 100 stroops  (10 %)
-    ///
-    /// The shares must sum to the net distributed amount and neither holder
-    /// may receive more than their proportional entitlement.
     #[test]
     fn test_multi_holder_dividend_majority_holder_receives_larger_share() {
         let env = Env::default();
@@ -161,25 +89,23 @@ mod issue_tests {
         let client = CreatorKeysContractClient::new(&env, &contract_id);
 
         let admin = Address::generate(&env);
-        client.set_key_price(&admin, &100i128);
+        client.set_key_price(&admin, &KEY_PRICE);
+        client.set_fee_config(&admin, &10_000, &0);
 
         let creator = register_creator(&env, &client, None);
 
         let wallet_a = Address::generate(&env);
         let wallet_b = Address::generate(&env);
 
-        // Mint enough XLM for both wallets to buy keys.
-        fund_wallet(&env, &wallet_a, 100_000_000);
-        fund_wallet(&env, &wallet_b, 100_000_000);
-
-        // Wallet A buys 90 keys; wallet B buys 10 keys.
-        client.buy_key(&creator, &wallet_a, &90i128, &None);
-        client.buy_key(&creator, &wallet_b, &10i128, &None);
+        for _ in 0..90 {
+            client.buy_key(&creator, &wallet_a, &KEY_PRICE, &None);
+        }
+        for _ in 0..10 {
+            client.buy_key(&creator, &wallet_b, &KEY_PRICE, &None);
+        }
 
-        // Verify total supply before distributing.
         assert_eq!(client.get_total_key_supply(&creator), 100u32);
 
-        // Use the #492 helper to confirm supply invariant holds after the buys.
         assert_supply_equals_holder_sum(
             &env,
             &client,
@@ -187,26 +113,18 @@ mod issue_tests {
             soroban_sdk::vec![&env, wallet_a.clone(), wallet_b.clone()],
         );
 
-        // Fund a distributor and call distribute_dividend with 1 000 stroops.
         let distributor = Address::generate(&env);
         let gross_amount: i128 = 1_000;
-        fund_wallet(&env, &distributor, gross_amount + 1_000_000 /* gas */);
         client.distribute_dividend(&creator, &distributor, &gross_amount);
 
-        // Query the claimable amounts for each holder.
         let claimable_a: i128 = client.get_claimable_dividend(&creator, &wallet_a);
         let claimable_b: i128 = client.get_claimable_dividend(&creator, &wallet_b);
 
-        // --- Acceptance criteria ---
-
-        // 1. Majority holder receives proportionally larger share.
         assert!(
             claimable_a > claimable_b,
             "Wallet A (90 keys) should receive more than wallet B (10 keys), \
              but got claimable_a={claimable_a}, claimable_b={claimable_b}"
         );
-
-        // 2. Exact proportional amounts.
         assert_eq!(
             claimable_a, 900,
             "Wallet A should receive 900 stroops (90% of 1000), got {claimable_a}"
@@ -216,16 +134,13 @@ mod issue_tests {
             "Wallet B should receive 100 stroops (10% of 1000), got {claimable_b}"
         );
 
-        // 3. Shares sum to the net distributed amount (1 000 stroops).
         let total_claimable = claimable_a + claimable_b;
         assert_eq!(
             total_claimable, gross_amount,
             "Claimable amounts ({total_claimable}) should sum to distributed amount ({gross_amount})"
         );
-
-        // 4. Neither holder receives more than their proportion.
         assert!(
-            claimable_a <= gross_amount * 90 / 100 + 1, // +1 for rounding tolerance
+            claimable_a <= gross_amount * 90 / 100 + 1,
             "Wallet A received more than its 90% proportion"
         );
         assert!(
@@ -234,13 +149,6 @@ mod issue_tests {
         );
     }
 
-    // =========================================================================
-    // Issue #491 – Supply cap blocks buy that would partially exceed the cap
-    // =========================================================================
-
-    /// With a cap of 10 and current supply at 8, a buy of 3 must revert
-    /// even though 2 of those keys are within the cap.  A buy of exactly 2
-    /// (filling to the cap) must succeed.
     #[test]
     fn test_supply_cap_rejects_partial_exceed() {
         let env = Env::default();
@@ -250,23 +158,20 @@ mod issue_tests {
         let client = CreatorKeysContractClient::new(&env, &contract_id);
 
         let admin = Address::generate(&env);
-        client.set_key_price(&admin, &100i128);
+        client.set_key_price(&admin, &KEY_PRICE);
 
-        // Register creator with supply cap = 10.
         let creator = register_creator(&env, &client, Some(10u32));
-
         let buyer = Address::generate(&env);
-        fund_wallet(&env, &buyer, 100_000_000);
 
-        // Buy 8 keys to bring supply to 8.
-        client.buy_key(&creator, &buyer, &8i128, &None);
+        for _ in 0..8 {
+            client.buy_key(&creator, &buyer, &KEY_PRICE, &None);
+        }
         assert_eq!(
             client.get_total_key_supply(&creator),
             8u32,
             "Total supply should be 8 after buying 8 keys"
         );
 
-        // Use the #492 helper.
         assert_supply_equals_holder_sum(
             &env,
             &client,
@@ -274,60 +179,41 @@ mod issue_tests {
             soroban_sdk::vec![&env, buyer.clone()],
         );
 
-        // Attempt to buy 3 more keys (would bring supply to 11 > cap 10).
-        let result = client.try_buy_key(&creator, &buyer, &3i128, &None);
+        for _ in 0..2 {
+            client.buy_key(&creator, &buyer, &KEY_PRICE, &None);
+        }
+        assert_eq!(
+            client.get_total_key_supply(&creator),
+            10u32,
+            "Total supply should be 10 after filling to the cap"
+        );
+
+        let result = client.try_buy_key(&creator, &buyer, &KEY_PRICE, &None);
         assert!(
             result.is_err(),
-            "Buying 3 keys when only 2 slots remain should revert, but it succeeded"
+            "Buying at the cap should revert, but it succeeded"
         );
 
-        // Error must be SupplyCapExceeded.
         let err = result.unwrap_err().unwrap();
         assert!(
             matches!(err, ContractError::SupplyCapExceeded),
             "Expected ContractError::SupplyCapExceeded, got {err:?}"
         );
 
-        // Total supply must still be 8 after the failed buy.
-        assert_eq!(
-            client.get_total_key_supply(&creator),
-            8u32,
-            "Total supply should remain at 8 after a reverted buy"
-        );
-
-        // Supply invariant must still hold.
-        assert_supply_equals_holder_sum(
-            &env,
-            &client,
-            &creator,
-            soroban_sdk::vec![&env, buyer.clone()],
-        );
-
-        // A buy of exactly 2 (filling to the cap) must succeed.
-        let buyer2 = Address::generate(&env);
-        fund_wallet(&env, &buyer2, 100_000_000);
-        client.buy_key(&creator, &buyer2, &2i128, &None);
         assert_eq!(
             client.get_total_key_supply(&creator),
             10u32,
-            "Total supply should be 10 after filling to the cap"
+            "Total supply should remain at 10 after a reverted buy"
         );
 
-        // Final supply invariant check with both holders.
         assert_supply_equals_holder_sum(
             &env,
             &client,
             &creator,
-            soroban_sdk::vec![&env, buyer.clone(), buyer2.clone()],
+            soroban_sdk::vec![&env, buyer.clone()],
         );
     }
 
-    // =========================================================================
-    // Issue #492 – assert_supply_equals_holder_sum used in existing buy/sell/
-    //              transfer flows (at least three existing-style test cases)
-    // =========================================================================
-
-    /// After buying keys the supply invariant must hold.
     #[test]
     fn test_invariant_after_buy() {
         let env = Env::default();
@@ -337,13 +223,12 @@ mod issue_tests {
         let client = CreatorKeysContractClient::new(&env, &contract_id);
 
         let admin = Address::generate(&env);
-        client.set_key_price(&admin, &100i128);
+        client.set_key_price(&admin, &KEY_PRICE);
 
         let creator = register_creator(&env, &client, None);
         let buyer = Address::generate(&env);
-        fund_wallet(&env, &buyer, 100_000_000);
 
-        client.buy_key(&creator, &buyer, &5i128, &None);
+        client.buy_key(&creator, &buyer, &KEY_PRICE, &None);
 
         assert_supply_equals_holder_sum(
             &env,
@@ -353,7 +238,6 @@ mod issue_tests {
         );
     }
 
-    /// After selling keys the supply invariant must hold.
     #[test]
     fn test_invariant_after_sell() {
         let env = Env::default();
@@ -363,15 +247,15 @@ mod issue_tests {
         let client = CreatorKeysContractClient::new(&env, &contract_id);
 
         let admin = Address::generate(&env);
-        client.set_key_price(&admin, &100i128);
+        client.set_key_price(&admin, &KEY_PRICE);
 
         let creator = register_creator(&env, &client, None);
         let buyer = Address::generate(&env);
-        fund_wallet(&env, &buyer, 100_000_000);
 
-        client.buy_key(&creator, &buyer, &10i128, &None);
+        for _ in 0..10 {
+            client.buy_key(&creator, &buyer, &KEY_PRICE, &None);
+        }
 
-        // Verify invariant before sell.
         assert_supply_equals_holder_sum(
             &env,
             &client,
@@ -379,9 +263,10 @@ mod issue_tests {
             soroban_sdk::vec![&env, buyer.clone()],
         );
 
-        client.sell_key(&creator, &buyer, &None);
+        for _ in 0..4 {
+            client.sell_key(&creator, &buyer, &None);
+        }
 
-        // Verify invariant after sell.
         assert_supply_equals_holder_sum(
             &env,
             &client,
@@ -396,7 +281,6 @@ mod issue_tests {
         );
     }
 
-    /// After transferring keys the supply invariant must hold.
     #[test]
     fn test_invariant_after_transfer() {
         let env = Env::default();
@@ -406,16 +290,16 @@ mod issue_tests {
         let client = CreatorKeysContractClient::new(&env, &contract_id);
 
         let admin = Address::generate(&env);
-        client.set_key_price(&admin, &100i128);
+        client.set_key_price(&admin, &KEY_PRICE);
 
         let creator = register_creator(&env, &client, None);
         let sender = Address::generate(&env);
         let receiver = Address::generate(&env);
-        fund_wallet(&env, &sender, 100_000_000);
 
-        client.buy_key(&creator, &sender, &8i128, &None);
+        for _ in 0..8 {
+            client.buy_key(&creator, &sender, &KEY_PRICE, &None);
+        }
 
-        // Verify invariant before transfer.
         assert_supply_equals_holder_sum(
             &env,
             &client,
@@ -425,8 +309,6 @@ mod issue_tests {
 
         client.transfer_keys(&creator, &sender, &receiver, &3u32);
 
-        // Verify invariant after transfer – total supply must not change,
-        // but balances must have shifted.
         assert_supply_equals_holder_sum(
             &env,
             &client,

From 9787711831d1c711a65e8c360045743c139819ab Mon Sep 17 00:00:00 2001
From: Godsmiracle001 <Miraxzeegame@gmail.com>
Date: Sat, 27 Jun 2026 18:27:42 +0100
Subject: [PATCH 6/6] fix(tests): resolve clippy error by adding missing
 curve_preset argument

---
 creator-keys/tests/locked_allocation_bonding_curve_supply.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/creator-keys/tests/locked_allocation_bonding_curve_supply.rs b/creator-keys/tests/locked_allocation_bonding_curve_supply.rs
index 67a7f84..f2ccb35 100644
--- a/creator-keys/tests/locked_allocation_bonding_curve_supply.rs
+++ b/creator-keys/tests/locked_allocation_bonding_curve_supply.rs
@@ -50,6 +50,7 @@ fn setup(
             claimed: false,
         }),
         &None,
+        &None,
     );
 
     let creator_no_alloc = Address::generate(env);
@@ -58,6 +59,7 @@ fn setup(
         &String::from_str(env, "bob"),
         &None,
         &None,
+        &None,
     );
 
     (client, creator_with_alloc, creator_no_alloc)