refactor: move tokenomics presets to presets package

Moves AutonomousBuyback and StreamToken preset contracts from
game_components_tokenomics to game_components_presets.

Changes:
- Added preset contracts to packages/presets/src/
- Updated presets Scarb.toml with tokenomics and interfaces dependencies
- Removed presets module from tokenomics package
- Added test-only preset contracts in tokenomics tests/mocks/ for unit testing
- Exported ERC20_UNIT constant from tokenomics for presets to use

This follows the pattern where components live in their own packages
and presets (deployable contracts) live in a central presets package.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pg-agent

packages/presets/Scarb.toml

@@ -7,10 +7,13 @@ edition.workspace = true
 
 [dependencies]
 game_components_leaderboard = { path = "../leaderboard" }
+game_components_tokenomics = { path = "../tokenomics" }
+game_components_interfaces = { path = "../interfaces" }
 starknet.workspace = true
 openzeppelin_token.workspace = true
 openzeppelin_introspection.workspace = true
 openzeppelin_access.workspace = true
+ekubo.workspace = true
 
 [[target.starknet-contract]]
 

…ics/src/presets/autonomous_buyback.cairo …ges/presets/src/autonomous_buyback.cairopackages/tokenomics/src/presets/autonomous_buyback.cairo renamed to packages/presets/src/autonomous_buyback.cairo packages/tokenomics/src/presets/autonomous_buyback.cairo renamed to packages/presets/src/autonomous_buyback.cairo

@@ -23,9 +23,9 @@ pub mod AutonomousBuyback {
     use game_components_interfaces::tokenomics::buyback::{
         GlobalBuybackConfig, IBuybackAdmin, TokenBuybackConfig,
     };
+    use game_components_tokenomics::buyback::BuybackComponent;
     use openzeppelin_access::ownable::OwnableComponent;
     use starknet::ContractAddress;
-    use crate::buyback::buyback::BuybackComponent;
 
     // Embed components
     component!(path: BuybackComponent, storage: buyback, event: BuybackEvent);

packages/presets/src/lib.cairo

@@ -8,5 +8,12 @@
 ///
 /// ## Available Presets
 /// - **Leaderboard**: Tournament leaderboard management with scoring and ranking
+/// - **AutonomousBuyback**: Autonomous token buyback via Ekubo TWAMM
+/// - **StreamToken**: ERC20 token with built-in TWAMM distribution
 
+pub mod autonomous_buyback;
 pub mod leaderboard;
+pub mod stream_token;
+
+pub use autonomous_buyback::AutonomousBuyback;
+pub use stream_token::StreamToken;

…okenomics/src/presets/stream_token.cairo packages/presets/src/stream_token.cairopackages/tokenomics/src/presets/stream_token.cairo renamed to packages/presets/src/stream_token.cairo packages/tokenomics/src/presets/stream_token.cairo renamed to packages/presets/src/stream_token.cairo

@@ -12,9 +12,10 @@
 #[starknet::contract]
 pub mod StreamToken {
     use game_components_interfaces::tokenomics::stream::{DistributionOrder, LiquidityConfig};
+    use game_components_tokenomics::ERC20_UNIT;
+    use game_components_tokenomics::stream::StreamComponent;
     use openzeppelin_token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
     use starknet::ContractAddress;
-    use crate::stream::stream::StreamComponent;
 
     // Embed components
     component!(path: ERC20Component, storage: erc20, event: ERC20Event);
@@ -102,7 +103,6 @@ pub mod StreamToken {
             );
 
         // Mint tokens to registry for registration (1 token = 10^18 units)
-        use crate::constants::ERC20_UNIT;
         self.erc20.mint(registry_address, ERC20_UNIT.into());
 
         // Register token with Ekubo

packages/tokenomics/src/lib.cairo

@@ -28,7 +28,6 @@
 pub mod buyback;
 pub mod constants;
 pub mod factory;
-pub mod presets;
 pub mod stream;
 
 // Re-exports for convenience - Buyback
@@ -39,7 +38,7 @@ pub use buyback::{
 };
 
 // Re-exports for convenience - Constants
-pub use constants::Errors;
+pub use constants::{ERC20_UNIT, Errors};
 
 // Re-exports for convenience - Factory
 pub use factory::StreamTokenFactory;

packages/tokenomics/src/presets.cairo

@@ -1,5 +1,9 @@
 pub mod mock_erc20;
 pub mod mock_registry;
+pub mod test_autonomous_buyback;
+pub mod test_stream_token;
 
 pub use mock_erc20::{IMockERC20Dispatcher, IMockERC20DispatcherTrait, MockERC20};
 pub use mock_registry::{IMockTokenRegistryDispatcher, IMockTokenRegistryDispatcherTrait};
+pub use test_autonomous_buyback::AutonomousBuyback;
+pub use test_stream_token::StreamToken;

packages/tokenomics/tests/mocks.cairo

@@ -0,0 +1,69 @@
+/// Test-only Autonomous Buyback contract for unit testing
+/// This is identical to the preset in game_components_presets but defined here
+/// so tokenomics tests can use `declare("AutonomousBuyback")`.
+#[starknet::contract]
+pub mod AutonomousBuyback {
+    use game_components_interfaces::tokenomics::buyback::{
+        GlobalBuybackConfig, IBuybackAdmin, TokenBuybackConfig,
+    };
+    use game_components_tokenomics::buyback::BuybackComponent;
+    use openzeppelin_access::ownable::OwnableComponent;
+    use starknet::ContractAddress;
+
+    component!(path: BuybackComponent, storage: buyback, event: BuybackEvent);
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+
+    #[abi(embed_v0)]
+    impl BuybackImpl = BuybackComponent::BuybackImpl<ContractState>;
+    impl BuybackInternalImpl = BuybackComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl OwnableMixinImpl = OwnableComponent::OwnableMixinImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        buyback: BuybackComponent::Storage,
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        BuybackEvent: BuybackComponent::Event,
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        owner: ContractAddress,
+        global_config: GlobalBuybackConfig,
+        positions_address: ContractAddress,
+        extension_address: ContractAddress,
+    ) {
+        self.ownable.initializer(owner);
+        self.buyback.initializer(global_config, positions_address, extension_address);
+    }
+
+    #[abi(embed_v0)]
+    impl BuybackAdminImpl of IBuybackAdmin<ContractState> {
+        fn set_global_config(ref self: ContractState, config: GlobalBuybackConfig) {
+            self.ownable.assert_only_owner();
+            self.buyback.set_global_config(config);
+        }
+
+        fn set_token_config(
+            ref self: ContractState,
+            sell_token: ContractAddress,
+            config: Option<TokenBuybackConfig>,
+        ) {
+            self.ownable.assert_only_owner();
+            self.buyback.set_token_config(sell_token, config);
+        }
+    }
+}

packages/tokenomics/tests/mocks/test_autonomous_buyback.cairo

@@ -0,0 +1,81 @@
+/// Test-only Stream Token contract for unit testing
+/// This is identical to the preset in game_components_presets but defined here
+/// so tokenomics tests can use `declare("StreamToken")`.
+#[starknet::contract]
+pub mod StreamToken {
+    use game_components_interfaces::tokenomics::stream::{DistributionOrder, LiquidityConfig};
+    use game_components_tokenomics::ERC20_UNIT;
+    use game_components_tokenomics::stream::StreamComponent;
+    use openzeppelin_token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use starknet::ContractAddress;
+
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+    component!(path: StreamComponent, storage: stream, event: StreamEvent);
+
+    pub impl ERC20Config of ERC20Component::ImmutableConfig {
+        const DECIMALS: u8 = 18;
+    }
+
+    #[abi(embed_v0)]
+    impl ERC20MixinImpl = ERC20Component::ERC20MixinImpl<ContractState>;
+    impl ERC20InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl StreamImpl = StreamComponent::StreamImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl StreamSetupImpl = StreamComponent::StreamSetupImpl<ContractState>;
+
+    impl StreamInternalImpl = StreamComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage,
+        #[substorage(v0)]
+        stream: StreamComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event,
+        #[flat]
+        StreamEvent: StreamComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        name: ByteArray,
+        symbol: ByteArray,
+        total_supply: u128,
+        factory: ContractAddress,
+        positions_address: ContractAddress,
+        core_address: ContractAddress,
+        registry_address: ContractAddress,
+        extension_address: ContractAddress,
+        liquidity_config: LiquidityConfig,
+        distribution_orders: Span<DistributionOrder>,
+    ) {
+        self.erc20.initializer(name, symbol);
+        self
+            .stream
+            .initializer(
+                factory,
+                positions_address,
+                core_address,
+                registry_address,
+                extension_address,
+                liquidity_config,
+                distribution_orders,
+            );
+
+        self.erc20.mint(registry_address, ERC20_UNIT.into());
+        self.stream.register_token();
+
+        let remaining_supply: u256 = (total_supply - ERC20_UNIT).into();
+        self.erc20.mint(factory, remaining_supply);
+    }
+}