add extra info to events

src/ComputePool.sol

@@ -156,7 +156,7 @@ contract ComputePool is IComputePool, AccessControlEnumerable {
 
         poolIdCounter++;
 
-        emit ComputePoolCreated(poolIdCounter - 1, domainId, msg.sender);
+        emit ComputePoolCreated(poolIdCounter - 1, domainId, msg.sender, computeManagerKey, computeLimit, poolDataURI);
 
         return poolIdCounter - 1;
     }

src/DomainRegistry.sol

@@ -30,7 +30,7 @@ contract DomainRegistry is IDomainRegistry, AccessControlEnumerable {
 
         domains.push(domain);
 
-        emit DomainCreated(name, domain.domainId);
+        emit DomainCreated(name, domain.domainId, address(validationContract), domainParametersURI);
 
         return domain.domainId;
     }

src/StakeManager.sol

@@ -46,14 +46,16 @@ contract StakeManager is IStakeManager, AccessControlEnumerable {
         _totalUnbonding += amount;
         if (_unbonds[staker].unbonds.length - _unbonds[staker].offset >= MAX_PENDING_UNBONDS) {
             // add to the newest unbond and reset the time
+            uint256 newExpiry = block.timestamp + _unbondingPeriod;
             UnbondTracker storage pending = _unbonds[staker];
             pending.unbonds[pending.unbonds.length - 1].amount += amount;
-            pending.unbonds[pending.unbonds.length - 1].timestamp = block.timestamp + _unbondingPeriod;
+            pending.unbonds[pending.unbonds.length - 1].timestamp = newExpiry;
+            emit PendingBondUpdated(staker, amount, pending.unbonds.length - 1, newExpiry);
         } else {
             // add a new unbond
             _unbonds[staker].unbonds.push(Unbond(amount, block.timestamp + _unbondingPeriod));
         }
-        emit Unstake(staker, amount);
+        emit Unstake(staker, amount, _unbonds[staker].unbonds.length - 1);
     }
 
     function rebond(address staker, uint256 amount) external onlyRole(PRIME_ROLE) {
@@ -71,12 +73,14 @@ contract StakeManager is IStakeManager, AccessControlEnumerable {
                 rebonded += unbond_amount;
                 delete pending.unbonds[i];
                 pending.offset = i + 1;
+                emit PendingBondRemoved(staker, unbond_amount, i);
             } else {
                 // only part of the unbond is rebonded
                 uint256 leftover = unbond_amount + rebonded - amount;
                 pending.unbonds[i].amount = leftover;
                 rebonded = amount;
                 pending.offset = i;
+                emit PendingBondUpdated(staker, leftover, i, pending.unbonds[i].timestamp);
                 break;
             }
         }
@@ -94,6 +98,7 @@ contract StakeManager is IStakeManager, AccessControlEnumerable {
                 _totalUnbonding -= pending[i].amount;
                 _unbonding[msg.sender] -= pending[i].amount;
                 delete pending[i];
+                emit PendingBondRemoved(msg.sender, pending[i].amount, i);
             } else {
                 _unbonds[msg.sender].offset = i;
                 break;
@@ -127,20 +132,18 @@ contract StakeManager is IStakeManager, AccessControlEnumerable {
                         pending.unbonds[i].amount = diff;
                         unbonding_amount = amount;
                         pending.offset = i;
-                        break;
-                    } else if (unbonding_amount == amount) {
-                        // slash the whole unbond
-                        _totalUnbonding -= pending.unbonds[i].amount;
-                        _unbonding[staker] -= pending.unbonds[i].amount;
-                        delete pending.unbonds[i];
-                        pending.offset = i + 1;
+                        emit PendingBondUpdated(staker, diff, i, pending.unbonds[i].timestamp);
                         break;
                     } else {
-                        // slash the whole unbond and continue
+                        // slash the whole unbond
                         _totalUnbonding -= pending.unbonds[i].amount;
                         _unbonding[staker] -= pending.unbonds[i].amount;
                         delete pending.unbonds[i];
                         pending.offset = i + 1;
+                        emit PendingBondRemoved(staker, pending.unbonds[i].amount, i);
+                        if (unbonding_amount == amount) {
+                            break;
+                        }
                     }
                 }
             }
@@ -198,6 +201,11 @@ contract StakeManager is IStakeManager, AccessControlEnumerable {
         return pendingUnbonds;
     }
 
+    function getUnbondAtIndex(address staker, uint256 index) external view returns (Unbond memory) {
+        require(index < _unbonds[staker].unbonds.length, "StakeManager: index out of bounds");
+        return _unbonds[staker].unbonds[_unbonds[staker].offset + index];
+    }
+
     function getPendingUnbondTotal(address staker) external view returns (uint256) {
         return _unbonding[staker];
     }

src/interfaces/IComputePool.sol

@@ -5,7 +5,14 @@ import "./IComputeRegistry.sol";
 import "./IRewardsDistributor.sol";
 import "@openzeppelin/contracts/access/extensions/IAccessControlEnumerable.sol";
 
-event ComputePoolCreated(uint256 indexed poolId, uint256 indexed domainId, address indexed creator);
+event ComputePoolCreated(
+    uint256 indexed poolId,
+    uint256 indexed domainId,
+    address indexed creator,
+    address manager,
+    uint256 limit,
+    string uri
+);
 
 event ComputePoolStarted(uint256 indexed poolId, uint256 timestamp);
 

src/interfaces/IDomainRegistry.sol

@@ -5,7 +5,7 @@ import "./IWorkValidation.sol";
 import "./IComputePool.sol";
 import "@openzeppelin/contracts/access/extensions/IAccessControlEnumerable.sol";
 
-event DomainCreated(string domainName, uint256 domainId);
+event DomainCreated(string domainName, uint256 domainId, address validationLogic, string domainParametersURI);
 
 event DomainUpdated(uint256 domainId, address validationLogic, string domainParametersURI);
 

src/interfaces/IStakeManager.sol

@@ -5,7 +5,7 @@ import "@openzeppelin/contracts/access/extensions/IAccessControlEnumerable.sol";
 
 event Stake(address staker, uint256 amount);
 
-event Unstake(address staker, uint256 amount);
+event Unstake(address staker, uint256 amount, uint256 index);
 
 event Withdraw(address staker, uint256 amount);
 
@@ -17,6 +17,10 @@ event UpdateUnbondingPeriod(uint256 period);
 
 event StakeMinimumUpdate(uint256 minimum);
 
+event PendingBondRemoved(address staker, uint256 amount, uint256 index);
+
+event PendingBondUpdated(address staker, uint256 amount, uint256 index, uint256 timestamp);
+
 interface IStakeManager is IAccessControlEnumerable {
     struct Unbond {
         uint256 amount;
@@ -35,6 +39,7 @@ interface IStakeManager is IAccessControlEnumerable {
     function getStake(address staker) external view returns (uint256);
     function getTotalStaked() external view returns (uint256);
     function getPendingUnbonds(address staker) external view returns (Unbond[] memory);
+    function getUnbondAtIndex(address staker, uint256 index) external view returns (Unbond memory);
     function getPendingUnbondTotal(address staker) external view returns (uint256);
     function getUnbondingPeriod() external view returns (uint256);
     function getTotalUnbonding() external view returns (uint256);

test/StakeManager.t.sol

@@ -79,7 +79,7 @@ contract StakeManagerTest is Test {
         _stake(staker, HUND);
 
         vm.expectEmit(true, false, false, true);
-        emit Unstake(staker, 40 * ONE);
+        emit Unstake(staker, 40 * ONE, 0);
 
         _unstake(staker, 40 * ONE);