Use eth for payments and add discounts

Author: RubenSousaDinis

contracts/talent_plus/README.md

@@ -4,7 +4,7 @@ This directory contains the core smart contracts for the TalentPlus subscription
 
 ## Overview
 
-The TalentPlus system enables trusted signers to purchase subscriptions for users using TALENT tokens, with flexible subscription models and administrative capabilities for custom subscription management. Trusted signers can purchase subscriptions for any wallet address, enabling gift subscriptions and corporate subscription management.
+The TalentPlus system enables trusted signers to purchase subscriptions for users using ETH payments, with flexible subscription models, TALENT token-based discounts (including vault staking), and administrative capabilities for custom subscription management. Trusted signers can purchase subscriptions for any wallet address, enabling gift subscriptions and corporate subscription management.
 
 ## Contracts
 
@@ -15,6 +15,8 @@ The core subscription management contract that handles subscription models and u
 #### Key Features
 
 - **Subscription Model Management**: Create, update, and deactivate subscription models
+- **TALENT Token Integration**: Check TALENT token balances and vault staking for discount eligibility
+- **Dynamic Discount System**: Apply discounts based on combined TALENT holdings (balance + vault staking)
 - **User Subscription Management**: Add, upgrade, and extend user subscriptions
 - **Custom Expiration Support**: Administrative function to set custom expiration times
 - **Access Control**: Owner and trusted signer permissions
@@ -23,8 +25,8 @@ The core subscription management contract that handles subscription models and u
 #### Main Functions
 
 **Subscription Model Management:**
-- `addSubscriptionModel(string subscriptionSlug, uint256 durationInSeconds, uint256 priceInTalent)`
-- `updateSubscriptionModel(string subscriptionSlug, uint256 durationInSeconds, uint256 priceInTalent)`
+- `addSubscriptionModel(string subscriptionSlug, uint256 durationInSeconds, uint256 priceInEth, uint256 discountPercentage, uint256 talentRequiredForDiscount)`
+- `updateSubscriptionModel(string subscriptionSlug, uint256 durationInSeconds, uint256 priceInEth, uint256 discountPercentage, uint256 talentRequiredForDiscount)`
 - `deactivateSubscriptionModel(string subscriptionSlug)`
 
 **User Subscription Management:**
@@ -37,6 +39,8 @@ The core subscription management contract that handles subscription models and u
 - `getCurrentActiveSubscription(address wallet)`
 - `getSubscriptionExpiration(address wallet)`
 - `getSubscriptionStartTime(address wallet)`
+- `getSubscriptionModel(string subscriptionSlug)` - Returns model details including discount info
+- `calculateDiscountedPrice(string subscriptionSlug, address wallet)` - Calculates final price with discount applied based on TALENT balance + vault staking
 
 **Access Control:**
 - `addTrustedSigner(address signer)`
@@ -62,32 +66,33 @@ struct UserActiveSubscription {
 
 ### 2. TalentPlus.sol
 
-The payment and subscription creation contract that handles TALENT token payments and integrates with TalentPlusSubscription. Only trusted signers can call the subscription functions.
+The payment and subscription creation contract that handles ETH payments and integrates with TalentPlusSubscription. Only trusted signers can call the subscription functions.
 
 #### Key Features
 
-- **TALENT Token Integration**: Handles ERC20 token payments for subscriptions
+- **ETH Payment Integration**: Handles native ETH payments for subscriptions
+- **TALENT-Based Discounts**: Automatically applies discounts based on TALENT token holdings and vault staking
 - **Direct Access Control**: Only trusted signers can create subscriptions
-- **Dynamic Pricing**: Fetches subscription costs from TalentPlusSubscription contract
+- **Dynamic Pricing**: Fetches subscription costs and applies discounts from TalentPlusSubscription contract
 - **Gift Subscriptions**: Trusted signers can purchase subscriptions for any wallet address
 - **Administrative Control**: Owner-managed contract settings
 - **Integration**: Seamless integration with TalentPlusSubscription
 
 #### Main Functions
 
 **Core Subscription:**
-- `subscribe(address wallet, string subscriptionSlug)` - Main subscription function (trusted signers can purchase for any wallet)
+- `subscribe(address wallet, string subscriptionSlug)` - Main subscription function (trusted signers can purchase for any wallet, requires ETH payment)
 
 **Administrative:**
 - `setEnabled(bool _enabled)` - Enable/disable contract
 - `setDisabled()` - Disable contract
-- `updateReceiver(address _feeReceiver)` - Update fee receiver address
+- `updateReceiver(address _feeReceiver)` - Update ETH fee receiver address
 - `updateTalentPlusSubscription(address _talentPlusSubscriptionAddress)` - Update subscription contract address
 
 #### Events
 
 ```solidity
-event SubscriptionCreated(address indexed payer, address indexed recipient, string subscriptionSlug);
+event SubscriptionCreated(address indexed payer, address indexed recipient, string subscriptionSlug, uint256 finalPrice, bool discountApplied);
 ```
 
 ## Integration Flow
@@ -102,14 +107,19 @@ sequenceDiagram
     participant TALENT_Token
     participant FeeReceiver
 
-    TrustedSigner->>TalentPlus: subscribe(wallet, slug)
+    TrustedSigner->>TalentPlus: subscribe(wallet, slug) + ETH
     TalentPlus->>TalentPlusSubscription: getSubscriptionModel(slug)
-    TalentPlusSubscription-->>TalentPlus: (duration, price, active)
+    TalentPlusSubscription-->>TalentPlus: (duration, price, discount%, talentRequired, active)
+    TalentPlus->>TalentPlusSubscription: calculateDiscountedPrice(slug, wallet)
+    TalentPlusSubscription->>TALENT_Token: balanceOf(wallet)
+    TALENT_Token-->>TalentPlusSubscription: balance
+    TalentPlusSubscription-->>TalentPlus: (finalPrice, discountApplied)
     TalentPlus->>TalentPlus: verify msg.sender == trustedSigner
-    TalentPlus->>TALENT_Token: transferFrom(trustedSigner, feeReceiver, price)
+    TalentPlus->>TalentPlus: verify msg.value >= finalPrice
+    TalentPlus->>FeeReceiver: transfer ETH
     TalentPlus->>TalentPlusSubscription: addUserSubscription(wallet, slug)
     TalentPlusSubscription-->>TalentPlus: success
-    TalentPlus->>TalentPlus: emit SubscriptionCreated(trustedSigner, wallet, slug)
+    TalentPlus->>TalentPlus: emit SubscriptionCreated(trustedSigner, wallet, slug, finalPrice, discountApplied)
 ```
 
 ### 2. Custom Subscription Flow
@@ -152,11 +162,37 @@ sequenceDiagram
 ### Basic Subscription Purchase
 
 ```solidity
-// Trusted signer purchases subscription for a user
-talentPlus.subscribe(userWallet, "premium");
+// Trusted signer purchases subscription for a user (full price)
+talentPlus.subscribe(userWallet, "premium", { value: parseEther("100") });
 
-// Trusted signer purchases subscription as a gift for another user
-talentPlus.subscribe(recipientWallet, "premium");
+// Trusted signer purchases subscription as a gift for another user (with discount)
+// User has 5000 TALENT tokens, so gets 20% discount on premium subscription
+talentPlus.subscribe(recipientWallet, "premium", { value: parseEther("80") }); // 100 - 20% = 80 ETH
+```
+
+### Discount System Management (Admin)
+
+```solidity
+// Admin creates subscription model with discount
+talentPlusSubscription.addSubscriptionModel(
+    "premium",           // subscription slug
+    90 * 24 * 60 * 60,   // 90 days duration
+    parseEther("100"),   // 100 ETH base price
+    20,                  // 20% discount
+    parseEther("5000")   // 5000 TALENT tokens required for discount
+);
+
+// Admin updates discount parameters
+talentPlusSubscription.updateSubscriptionModel(
+    "premium",
+    90 * 24 * 60 * 60,
+    parseEther("100"),
+    25,                  // Updated to 25% discount
+    parseEther("10000")  // Updated to 10000 TALENT tokens required
+);
+
+// Check discounted price for a specific wallet
+(uint256 finalPrice, bool discountApplied) = talentPlusSubscription.calculateDiscountedPrice("premium", userWallet);
 ```
 
 ### Custom Subscription Creation (Admin)
@@ -251,15 +287,44 @@ npx hardhat test test/contracts/talent_plus/
 - **Corporate Subscriptions**: Companies can manage subscriptions for their employees
 - **Promotional Subscriptions**: Marketing teams can give away subscriptions
 - **Admin-Managed Subscriptions**: Administrators can create subscriptions for users
+- **TALENT Holder Rewards**: Users with TALENT tokens or vault staking get automatic discounts
+- **Tiered Pricing**: Different discount levels based on combined TALENT holdings (balance + vault staking)
+
+### Discount System Benefits
+- **Automatic Discounts**: No manual intervention required - discounts applied automatically
+- **TALENT Token Utility**: Increases value and utility of TALENT tokens and vault staking
+- **Flexible Configuration**: Admins can adjust discount percentages and requirements
+- **Transparent Pricing**: Users can check their discounted price before purchasing
+- **Fair Access**: Discounts based on actual token holdings and vault staking, not arbitrary criteria
+
+## Vault Integration
+
+The TalentPlus system integrates with the Talent Vault contract to provide enhanced discount eligibility based on staked TALENT tokens.
+
+### Vault Address
+- **Mainnet**: `0x23Ff3256A29847d7EF760943bd6679b565CbdE5a`
+- **Testnet**: `0x23Ff3256A29847d7EF760943bd6679b565CbdE5a` (same address)
+
+### How Vault Staking Works
+1. **Combined Holdings**: Discount eligibility is calculated using `TALENT balance + vault staked amount`
+2. **Automatic Detection**: The system automatically checks both wallet balance and vault staking
+3. **Seamless Integration**: Users don't need to do anything special - staking automatically qualifies them for discounts
+4. **Flexible Requirements**: Admins can set discount thresholds that consider both sources of TALENT holdings
+
+### Example Scenarios
+- **Scenario 1**: User has 500 TALENT in wallet + 500 TALENT staked in vault = 1000 TALENT total → qualifies for discount
+- **Scenario 2**: User has 0 TALENT in wallet + 1000 TALENT staked in vault = 1000 TALENT total → qualifies for discount  
+- **Scenario 3**: User has 1000 TALENT in wallet + 0 TALENT staked in vault = 1000 TALENT total → qualifies for discount
 
 ## Dependencies
 
-- **OpenZeppelin Contracts**: `Ownable`, `ReentrancyGuard`, `IERC20`, `SafeERC20`
+- **OpenZeppelin Contracts**: `Ownable`, `ReentrancyGuard`, `IERC20`
 - **Solidity**: `^0.8.24`
 
 ## Network Configuration
 
 The contracts support both mainnet and testnet deployments with network-specific configurations for:
 - TALENT token addresses
+- Vault contract addresses
 - Fee receiver addresses
 - Trusted signer addresses

contracts/talent_plus/TalentPlus.sol

@@ -1,36 +1,28 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "./TalentPlusSubscription.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 
 contract TalentPlus is Ownable, ReentrancyGuard {
-    using SafeERC20 for IERC20;
-
-    // TALENT token address
-    IERC20 public immutable TALENT_TOKEN;
 
     address public trustedSigner;
     address public feeReceiver;
     TalentPlusSubscription public talentPlusSubscription;
 
-    event SubscriptionCreated(address indexed payer, address indexed recipient, string subscriptionSlug);
+    event SubscriptionCreated(address indexed payer, address indexed recipient, string subscriptionSlug, uint256 finalPrice, bool discountApplied);
 
     bool public enabled;
 
     constructor(
         address _trustedSigner,
         address _talentPlusSubscriptionAddress,
-        address _feeReceiver,
-        address _talentTokenAddress
+        address _feeReceiver
     ) Ownable(msg.sender) {
         trustedSigner = _trustedSigner;
         talentPlusSubscription = TalentPlusSubscription(_talentPlusSubscriptionAddress);
         feeReceiver = _feeReceiver;
-        TALENT_TOKEN = IERC20(_talentTokenAddress);
         enabled = true;
     }
 
@@ -75,23 +67,35 @@ contract TalentPlus is Ownable, ReentrancyGuard {
      * @param wallet The wallet address to create the subscription for.
      * @param subscriptionSlug The subscription slug to set in TalentPlusSubscription.
      * @dev Only the trusted signer can call this function. TalentPlus contract is a trusted signer in TalentPlusSubscription.
+     * @dev Requires ETH payment equal to the subscription cost.
      */
-    function subscribe(address wallet, string memory subscriptionSlug) public nonReentrant {
+    function subscribe(address wallet, string memory subscriptionSlug) public payable nonReentrant {
         require(enabled, "Subscription is disabled for this contract");
         require(wallet != address(0), "Invalid wallet address");
         require(bytes(subscriptionSlug).length > 0, "Subscription slug cannot be empty");
         require(msg.sender == trustedSigner, "Only trusted signer can create subscriptions");
 
-        // Get the subscription model details including price
-        (, uint256 subscriptionCost, bool isActive) = talentPlusSubscription.getSubscriptionModel(subscriptionSlug);
+        // Get the subscription model details and calculate discounted price
+        (, , , , bool isActive) = talentPlusSubscription.getSubscriptionModel(subscriptionSlug);
         require(isActive, "Subscription model is not active");
+        
+        // Calculate discounted price based on TALENT holdings
+        (uint256 finalPrice, bool discountApplied,) = talentPlusSubscription.calculateDiscountedPrice(subscriptionSlug, wallet);
+        require(msg.value >= finalPrice, "Insufficient ETH payment");
+
+        // Transfer ETH to fee receiver
+        (bool success, ) = feeReceiver.call{value: finalPrice}("");
+        require(success, "ETH transfer failed");
 
-        // Transfer TALENT tokens from trusted signer to fee receiver
-        TALENT_TOKEN.safeTransferFrom(msg.sender, feeReceiver, subscriptionCost);
+        // Refund excess ETH if any
+        if (msg.value > finalPrice) {
+            (bool refundSuccess, ) = msg.sender.call{value: msg.value - finalPrice}("");
+            require(refundSuccess, "ETH refund failed");
+        }
 
         // Set the subscription for the target wallet in TalentPlusSubscription
         talentPlusSubscription.addUserSubscription(wallet, subscriptionSlug);
 
-        emit SubscriptionCreated(msg.sender, wallet, subscriptionSlug);
+        emit SubscriptionCreated(msg.sender, wallet, subscriptionSlug, finalPrice, discountApplied);
     }
 }