fix: correct incentive architecture — investment → training → inference → dividends

- purchaseShares deposits fund training pool (unchanged)
- claimTrainingReward now mints fresh ATN proportional to contribution,
  capped by the training pool budget — ATN emerges from training, not pre-mint
- recordInference pulls payment from requester (transferFrom) before
  distributing: 60% provider, 15% treasury, 25% dividend pool
- Separate dividendPoolBalances from tokenPoolBalances — training pool and
  dividend pool are independent, no cross-contamination
- Remove duplicate OnlyDAO error, consolidate on NotDAO
- Tests updated: requester approves before inference, training claim has
  no token arg (always mints ATN), dividend pool assertions use new getter

301 Hardhat tests passing.

Author: EightRice

cache/solidity-files-cache.json

@@ -2117,8 +2117,8 @@
       ]
     },
     "C:\\code\\autonet\\contracts\\core\\RPB.sol": {
-      "lastModificationDate": 1775427060074,
-      "contentHash": "d7fa0defd6ceb3043713694db38367b2",
+      "lastModificationDate": 1775428571872,
+      "contentHash": "35a318fbe7aa4480caaf921d329fb442",
       "sourceName": "contracts/core/RPB.sol",
       "solcConfig": {
         "version": "0.8.20",

contracts/core/RPB.sol

@@ -100,24 +100,28 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
     // --- Authorized minters (for BME bridge, disbursers, etc.) ---
     mapping(address => bool) public authorizedMinters;
 
-    // --- Training rewards ---
-    uint256 public trainingRewardPool;
-    uint256 public totalTrainingTokens;
+    // --- Training rewards (funded by share purchases, caps ATN minting) ---
+    uint256 public trainingRewardPool;       // normalized value: total budget ceiling for minting
+    uint256 public totalTrainingTokens;      // total contribution units across all agents
+    uint256 public totalTrainingMinted;      // total ATN minted as training rewards
     uint256 public currentEpoch;
     mapping(uint256 => TrainingRecord[]) public epochRecords;
     mapping(address => uint256) public agentTrainingTokens;
     mapping(address => uint256) public claimedRewards;
 
-    // --- Per-token pool tracking (token address -> amount held in raw token units) ---
+    // --- Per-token pool tracking for training pool (token address -> raw units held) ---
     mapping(address => uint256) public tokenPoolBalances;
 
     // --- RPB shares (claims on inference dividends) ---
     uint256 public totalShares;
     mapping(address => uint256) public shares;
-    uint256 public totalInferenceRevenue;
+    uint256 public totalInferenceRevenue;     // cumulative normalized inference revenue
     uint256 public totalDividendsPaid;
     mapping(address => uint256) public lastDividendClaim;
 
+    // --- Dividend pool (separate from training pool, funded by inference revenue) ---
+    mapping(address => uint256) public dividendPoolBalances;  // token -> raw units held for dividends
+
     // --- Inference accounting ---
     uint256 public totalInferenceUnits;
     uint256 public inferenceProviderShare;     // Basis points
@@ -205,7 +209,6 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
     error NoShares();
     error NoSharesOutstanding();
     error NoDividendsToClaim();
-    error OnlyDAO();
     error RevenueSplitInvalid();
     error TransferFailed();
     error ProviderPaymentFailed();
@@ -499,36 +502,30 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
     }
 
     /**
-     * @notice Claim training rewards, withdrawn in a specific value-index token.
-     * @param token ERC20 token to receive (must be in value index; use address(this) for ATN)
+     * @notice Claim training rewards as freshly minted ATN.
+     * @dev ATN is minted proportional to the agent's training contribution,
+     *      capped by the training reward pool (funded by share purchases).
      */
-    function claimTrainingReward(address token) external nonReentrant {
+    function claimTrainingReward() external nonReentrant {
         uint256 tokens = agentTrainingTokens[msg.sender];
         uint256 alreadyClaimed = claimedRewards[msg.sender];
         if (tokens <= alreadyClaimed) revert NoRewardsToClaim();
         if (trainingRewardPool == 0 || totalTrainingTokens == 0) revert RewardPoolEmpty();
 
         uint256 unclaimed = tokens - alreadyClaimed;
-        uint256 normalizedReward = (unclaimed * trainingRewardPool) / totalTrainingTokens;
+        uint256 reward = (unclaimed * trainingRewardPool) / totalTrainingTokens;
 
-        if (normalizedReward > trainingRewardPool) {
-            normalizedReward = trainingRewardPool;
+        if (reward > trainingRewardPool) {
+            reward = trainingRewardPool;
         }
-
-        uint256 rawAmount = _denormalize(token, normalizedReward);
-        if (rawAmount == 0) revert NoRewardsToClaim();
-        if (tokenPoolBalances[token] < rawAmount) revert InsufficientPoolBalance();
+        if (reward == 0) revert NoRewardsToClaim();
 
         claimedRewards[msg.sender] = tokens;
-        trainingRewardPool -= normalizedReward;
-        tokenPoolBalances[token] -= rawAmount;
+        totalTrainingMinted += reward;
+        agents[msg.sender].totalRewardsEarned += reward;
 
-        if (token == address(this)) {
-            _transfer(address(this), msg.sender, rawAmount);
-        } else {
-            if (!IERC20(token).transfer(msg.sender, rawAmount)) revert TransferFailed();
-        }
-        emit RewardClaimed(msg.sender, token, rawAmount);
+        _mint(msg.sender, reward);
+        emit RewardClaimed(msg.sender, address(this), reward);
     }
 
     /**
@@ -583,11 +580,11 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
 
         uint256 rawAmount = _denormalize(token, normalizedToClaim);
         if (rawAmount == 0) revert NoDividendsToClaim();
-        if (tokenPoolBalances[token] < rawAmount) revert InsufficientPoolBalance();
+        if (dividendPoolBalances[token] < rawAmount) revert InsufficientPoolBalance();
 
         lastDividendClaim[msg.sender] = myShare;
         totalDividendsPaid += normalizedToClaim;
-        tokenPoolBalances[token] -= rawAmount;
+        dividendPoolBalances[token] -= rawAmount;
 
         if (token == address(this)) {
             _transfer(address(this), msg.sender, rawAmount);
@@ -610,6 +607,13 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
     ) external onlyOperator nonReentrant {
         if (!agents[provider].active) revert AgentNotActive();
 
+        // Pull payment from the requester
+        if (token == address(this)) {
+            _transfer(requester, address(this), cost);
+        } else {
+            if (!IERC20(token).transferFrom(requester, address(this), cost)) revert TransferFailed();
+        }
+
         uint256 normalizedCost = _normalize(token, cost);
 
         totalInferenceUnits += units;
@@ -627,6 +631,7 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
         uint256 treasuryPayment = (cost * treasuryShare) / 10000;
         uint256 shareholderPoolPayment = cost - providerPayment - treasuryPayment;
 
+        // Distribute provider and treasury shares
         if (token == address(this)) {
             if (providerPayment > 0) _transfer(address(this), provider, providerPayment);
             if (treasuryPayment > 0) _transfer(address(this), dao, treasuryPayment);
@@ -639,8 +644,9 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
             }
         }
 
+        // Shareholder portion goes to dividend pool (separate from training pool)
         if (shareholderPoolPayment > 0) {
-            tokenPoolBalances[token] += shareholderPoolPayment;
+            dividendPoolBalances[token] += shareholderPoolPayment;
         }
 
         emit InferenceServed(provider, requester, units, normalizedCost);
@@ -671,9 +677,9 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
             }
         }
 
-        // Track shareholder pool (bridge already minted ATN to this contract)
+        // Track dividend pool (bridge already minted ATN to this contract)
         if (shareholderAmount > 0) {
-            tokenPoolBalances[address(this)] += shareholderAmount;
+            dividendPoolBalances[address(this)] += shareholderAmount;
         }
 
         emit InferenceServed(provider, requester, units, totalRevenue);
@@ -782,7 +788,7 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
         uint256 _shareholderShare,
         uint256 _treasuryShare
     ) external {
-        if (msg.sender != dao) revert OnlyDAO();
+        if (msg.sender != dao) revert NotDAO();
         if (_providerShare + _shareholderShare + _treasuryShare != 10000) revert RevenueSplitInvalid();
         inferenceProviderShare = _providerShare;
         shareholderShare = _shareholderShare;
@@ -856,6 +862,10 @@ contract RPB is ReentrancyGuard, ERC20, ERC20Permit, ERC20Votes, ERC20Burnable {
         return tokenPoolBalances[token];
     }
 
+    function getDividendPoolBalance(address token) external view returns (uint256) {
+        return dividendPoolBalances[token];
+    }
+
     function getRegisteredAgents() external view returns (address[] memory) {
         return registeredAgentList;
     }

tests/contracts-full.test.js

@@ -1791,7 +1791,7 @@ describe("Autonet Contracts — Full Test Suite", function () {
       // Only DAO can update revenue split
       await expect(
         rpb.connect(f.user1).updateRevenueSplit(3000, 3000, 3000)
-      ).to.be.revertedWithCustomError(rpb, "OnlyDAO");
+      ).to.be.revertedWithCustomError(rpb, "NotDAO");
     });
 
     it("alignment updates", async function () {

tests/economic-loop.test.js

@@ -317,10 +317,10 @@ describe("Full Economic Loop — E2E", function () {
         ethers.ZeroAddress
       );
 
-      // Fund RPB with ATN for inference payments (owner sends to RPB)
-      await rpb.transfer(rpbAddr, e18(10000));
+      // Requester approves RPB to pull inference payment
+      await rpb.connect(investor1).approve(rpbAddr, e18(10000));
 
-      // Record inference (owner is contract owner, can call recordInference)
+      // Record inference — RPB pulls 1000 ATN from requester, splits it
       // 100 units, 1000 ATN cost, paid in ATN (address(this))
       await rpb.recordInference(
         investor1.address, // requester
@@ -395,13 +395,13 @@ describe("Full Economic Loop — E2E", function () {
       expect(unclaimed).to.equal(e18(5000));
 
       const balBefore = await rpb.balanceOf(solver1.address);
-      await rpb.connect(solver1).claimTrainingReward(rpbAddr);
+      await rpb.connect(solver1).claimTrainingReward();
       const balAfter = await rpb.balanceOf(solver1.address);
       expect(balAfter - balBefore).to.equal(e18(5000));
 
       // Cannot double-claim
       await expect(
-        rpb.connect(solver1).claimTrainingReward(rpbAddr)
+        rpb.connect(solver1).claimTrainingReward()
       ).to.be.revertedWithCustomError(rpb, "NoRewardsToClaim");
     });
   });
@@ -501,7 +501,7 @@ describe("Full Economic Loop — E2E", function () {
       );
 
       // ── D: Inference generates revenue ──
-      await rpb.transfer(rpbAddr, e18(10000)); // Fund RPB for inference payments
+      await rpb.connect(investor1).approve(rpbAddr, e18(10000));
       await rpb.recordInference(
         investor1.address,  // requester
         solver1.address,    // provider
@@ -534,8 +534,8 @@ describe("Full Economic Loop — E2E", function () {
         lineage, ethers.randomBytes(32), ethers.ZeroAddress, ethers.ZeroAddress
       );
 
-      // Fund RPB for payments
-      await rpb.transfer(rpbAddr, e18(10000));
+      // Requester approves RPB to pull inference payment
+      await rpb.connect(investor1).approve(rpbAddr, e18(10000));
 
       const providerBefore = await rpb.balanceOf(solver1.address);
       const daoBefore = await rpb.balanceOf(owner.address); // owner = dao in test
@@ -551,8 +551,8 @@ describe("Full Economic Loop — E2E", function () {
       expect(providerAfter - providerBefore).to.equal(e18(600));
       // DAO/treasury gets 15%
       expect(daoAfter - daoBefore).to.equal(e18(150));
-      // Remaining 25% stays in RPB contract for shareholders
-      const shareholderPool = await rpb.getTokenPoolBalance(rpbAddr);
+      // Remaining 25% stays in RPB contract's dividend pool for shareholders
+      const shareholderPool = await rpb.getDividendPoolBalance(rpbAddr);
       expect(shareholderPool).to.equal(e18(250));
     });
   });