feat(indexer): canonical staking naming and local-dev resilience (#96)

* feat(indexer): canonical staking naming and local-dev resilience

* refactor: canonicalize staking terminology across non-native flows

Author: drewstone

AUDIT-PAYMENTS.md

@@ -2,13 +2,13 @@
 
 **Date:** 2026-02-03  
 **Auditor:** Subagent (payments-audit)  
-**Scope:** Payment distribution flow, operator vs restaker compensation
+**Scope:** Payment distribution flow, operator vs staker compensation
 
 ---
 
 ## Executive Summary
 
-The claims under investigation are **TECHNICALLY VALID** but the design appears **INTENTIONAL** for a restaking protocol where operator compensation is based on **risk commitment** (exposure) rather than **capital provided** (stake).
+The claims under investigation are **TECHNICALLY VALID** but the design appears **INTENTIONAL** for a staking protocol where operator compensation is based on **risk commitment** (exposure) rather than **capital provided** (stake).
 
 ### Claims Investigated:
 1. ✅ **CONFIRMED**: "Operator payment share is based on exposureBps (their claimed commitment), NOT actual stake"
@@ -74,7 +74,7 @@ function joinService(uint64 serviceId, uint16 exposureBps) external whenNotPause
 ```solidity
 function calculateOperatorPayments(
     uint256 totalOperatorAmount,
-    uint256 totalRestakerAmount,
+    uint256 totalStakerAmount,
     address[] memory operators,
     uint16[] memory exposures,      // <-- This is exposureBps, NOT stake
     uint256 totalExposure
@@ -93,12 +93,12 @@ function calculateOperatorPayments(
             payments[i] = OperatorPayment({
                 operator: operators[i],
                 operatorShare: totalOperatorAmount - operatorDistributed,
-                restakerShare: totalRestakerAmount - restakerDistributed
+                stakerShare: totalStakerAmount - stakerDistributed
             });
         } else {
             // KEY CALCULATION: Payment based on exposure, NOT actual stake
             uint256 opShare = (totalOperatorAmount * exposure) / totalExposure;
-            uint256 restakeShare = (totalRestakerAmount * exposure) / totalExposure;
+            uint256 stakeShare = (totalStakerAmount * exposure) / totalExposure;
             // ...
         }
     }
@@ -110,14 +110,14 @@ The `exposure` variable in the payment calculation is **directly** the `exposure
 
 ---
 
-## 3. Restaker Payment Path (Contrasting Behavior)
+## 3. Staker Payment Path (Contrasting Behavior)
 
 **File:** `src/rewards/ServiceFeeDistributor.sol`
 
-The restaker share flows to `ServiceFeeDistributor.distributeServiceFee()` which **DOES** use actual stake:
+The staker share flows to `ServiceFeeDistributor.distributeServiceFee()` which **DOES** use actual stake:
 
 ```solidity
-// Restaker distribution uses actual delegation scores
+// Staker distribution uses actual delegation scores
 mapping(address => mapping(bytes32 => uint256)) public totalAllScore;
 mapping(address => mapping(uint64 => mapping(bytes32 => uint256))) public totalFixedScore;
 ```
@@ -129,7 +129,7 @@ uint256 scoreDelta = (amount * lockMultiplierBps) / BPS_DENOMINATOR;
 totalAllScore[operator][assetHash] += scoreDelta;
 ```
 
-**Restaker payments ARE weighted by actual capital provided.**
+**Staker payments ARE weighted by actual capital provided.**
 
 ---
 
@@ -166,7 +166,7 @@ Higher exposure = more slashable stake. So `exposureBps` represents **risk commi
 1. **Risk-based compensation**: Operators are paid for slashing risk taken (exposure), not capital provided
 2. **Separation of concerns**: 
    - Operator share → compensation for service provision and risk commitment
-   - Restaker share → return on capital (correctly uses actual stake)
+   - Staker share → return on capital (correctly uses actual stake)
 3. **Slashing alignment**: `exposureBps` directly affects slashable amount, creating economic alignment
 
 ### Evidence Supporting POTENTIAL ISSUE:
@@ -229,7 +229,7 @@ Payments._distributePayment()
     │   • developerAmount
     │   • protocolAmount  
     │   • operatorAmount  ──────────────────────┐
-    │   • restakerAmount  ───────────────────┐  │
+    │   • stakerAmount  ───────────────────┐  │
     │                                        │  │
     ▼                                        │  │
 PaymentLib.calculateOperatorPayments()       │  │
@@ -240,7 +240,7 @@ PaymentLib.calculateOperatorPayments()       │  │
     ├── operatorShare → _pendingRewards      │  │
     │                   (based on exposure)  │  │
     │                                        │  │
-    └── restakerShare ───────────────────────┘  │
+    └── stakerShare ───────────────────────┘  │
               │                                 │
               ▼                                 │
     ServiceFeeDistributor.distributeServiceFee()
@@ -249,7 +249,7 @@ PaymentLib.calculateOperatorPayments()       │  │
               │  (Based on ACTUAL delegated amounts)
               │
               ▼
-        Restaker rewards (stake-weighted)
+        Staker rewards (stake-weighted)
 ```
 
 ---
@@ -261,9 +261,9 @@ The payment system has **two distinct compensation models**:
 | Recipient | Compensation Basis | Variable Used | Correct? |
 |-----------|-------------------|---------------|----------|
 | Operators | Risk commitment (exposure) | `exposureBps` | By design |
-| Restakers | Capital provided (stake) | `totalAllScore` | ✅ Yes |
+| Stakers | Capital provided (stake) | `totalAllScore` | ✅ Yes |
 
-The operator payment path using `exposureBps` instead of actual stake is **likely intentional** for a restaking protocol where operators are compensated for the slashing risk they accept, while restakers are compensated for capital provided.
+The operator payment path using `exposureBps` instead of actual stake is **likely intentional** for a staking protocol where operators are compensated for the slashing risk they accept, while stakers are compensated for capital provided.
 
 **However**, without explicit documentation or proportionality guards, this creates potential for gaming if slashing is not credibly enforced.
 

bindings/CHANGELOG.md

@@ -65,10 +65,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- **BREAKING**: Renamed `IRestaking` to `IStaking` interface
-- **BREAKING**: Renamed `restaking` module to `staking`
-- **BREAKING**: Renamed `PaymentSplit.restakerBps` to `stakerBps`
-- Updated all bindings from TNT Core contracts with restaking→staking terminology refactoring
+- **BREAKING**: Normalized interface names to `IStaking`
+- **BREAKING**: Normalized module naming to `staking`
+- **BREAKING**: Normalized `PaymentSplit` staking weight field naming
+- Updated all bindings from TNT Core contracts with canonical staking terminology
 
 ## [0.6.1] - 2026-01-17
 

bindings/Cargo.toml

@@ -3,13 +3,13 @@ name = "tnt-core-bindings"
 version = "0.10.4"
 edition = "2021"
 rust-version = "1.81"
-description = "Rust bindings for TNT Core Solidity contracts (Tangle restaking protocol)"
+description = "Rust bindings for TNT Core Solidity contracts (Tangle staking protocol)"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/tangle-network/tnt-core"
 homepage = "https://tangle.tools"
 documentation = "https://docs.rs/tnt-core-bindings"
 readme = "README.md"
-keywords = ["tangle", "restaking", "ethereum", "solidity", "alloy"]
+keywords = ["tangle", "staking", "ethereum", "solidity", "alloy"]
 categories = ["cryptography::cryptocurrencies", "api-bindings"]
 include = [
     "src/**/*",

bindings/TNT_CORE_VERSION

@@ -1 +1 @@
-32055b63efa6cb4c8f690f14a572c74275e5a411
+da2b9a8f57e6bf0af537b58c6f58f4b9fe0f5b67

bindings/abi/IMultiAssetDelegation.json

@@ -10135,7 +10135,7 @@ interface ITangle {
     event OperatorRegistered(uint64 indexed blueprintId, address indexed operator, bytes ecdsaPublicKey, string rpcAddress);
     event OperatorRewardAccrued(uint64 indexed serviceId, address indexed operator, address indexed token, uint64 blueprintId, uint256 amount);
     event OperatorUnregistered(uint64 indexed blueprintId, address indexed operator);
-    event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, address indexed token, uint256 grossAmount, address developerRecipient, uint256 developerAmount, uint256 protocolAmount, uint256 operatorPoolAmount, uint256 restakerPoolAmount);
+    event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, address indexed token, uint256 grossAmount, address developerRecipient, uint256 developerAmount, uint256 protocolAmount, uint256 operatorPoolAmount, uint256 stakerPoolAmount);
     event RewardsClaimed(address indexed account, address indexed token, uint256 amount);
     event ServiceActivated(uint64 indexed serviceId, uint64 indexed requestId, uint64 indexed blueprintId);
     event ServiceApproved(uint64 indexed requestId, address indexed operator);
@@ -14166,7 +14166,7 @@ interface ITangle {
         "internalType": "uint256"
       },
       {
-        "name": "restakerPoolAmount",
+        "name": "stakerPoolAmount",
         "type": "uint256",
         "indexed": false,
         "internalType": "uint256"
@@ -16378,7 +16378,7 @@ event OperatorUnregistered(uint64 indexed blueprintId, address indexed operator)
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Event with signature `PaymentDistributed(uint64,uint64,address,uint256,address,uint256,uint256,uint256,uint256)` and selector `0xbbd9474fbbb06eb636eb470aa71ad2133b5178d91593f96b8083204a60bea278`.
 ```solidity
-event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, address indexed token, uint256 grossAmount, address developerRecipient, uint256 developerAmount, uint256 protocolAmount, uint256 operatorPoolAmount, uint256 restakerPoolAmount);
+event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, address indexed token, uint256 grossAmount, address developerRecipient, uint256 developerAmount, uint256 protocolAmount, uint256 operatorPoolAmount, uint256 stakerPoolAmount);
 ```*/
     #[allow(
         non_camel_case_types,
@@ -16405,7 +16405,7 @@ event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, a
         #[allow(missing_docs)]
         pub operatorPoolAmount: alloy::sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub restakerPoolAmount: alloy::sol_types::private::primitives::aliases::U256,
+        pub stakerPoolAmount: alloy::sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -16456,7 +16456,7 @@ event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, a
                     developerAmount: data.2,
                     protocolAmount: data.3,
                     operatorPoolAmount: data.4,
-                    restakerPoolAmount: data.5,
+                    stakerPoolAmount: data.5,
                 }
             }
             #[inline]
@@ -16494,7 +16494,7 @@ event PaymentDistributed(uint64 indexed serviceId, uint64 indexed blueprintId, a
                     > as alloy_sol_types::SolType>::tokenize(&self.operatorPoolAmount),
                     <alloy::sol_types::sol_data::Uint<
                         256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.restakerPoolAmount),
+                    > as alloy_sol_types::SolType>::tokenize(&self.stakerPoolAmount),
                 )
             }
             #[inline]