fix(contract): charge attestation storage by measured delta; fund e2e onboarding

The fixed MINIMUM_ATTESTATION_STORAGE_DEPOSIT floor rejected zero-deposit
submissions outright. Restore the pre-#3714 behavior: charge only the measured
storage delta and reject only when the attached deposit is below it. A
participant re-attesting an unchanged entry grows nothing, so it pays nothing
and its function-call key works; a new entry costs the measured delta, funded
by a deposit-capable caller.

In e2e, fund each new participant's first attestation before resharing, signed
with the node's near_signer_key so the stored account_public_key matches the key
the node later uses for key-event votes (an operator key would store the wrong
key and stall resharing). Add MpcNodeState::near_signer_key for this.

Repurpose the worst-case test to assert the entry cost stays under a bounded
ceiling, and regenerate the ABI snapshot.

Author: pbeza

crates/contract/src/lib.rs

@@ -117,11 +117,6 @@ const MINIMUM_CKD_REQUEST_DEPOSIT: NearToken = NearToken::from_yoctonear(1);
 /// node key cannot invoke these methods.
 pub const MINIMUM_NODE_MANAGEMENT_DEPOSIT: NearToken = NearToken::from_yoctonear(1);
 
-/// Minimum a node must attach to [`MpcContract::submit_participant_info`],
-/// sized to cover the worst-case stored entry. Only the actual storage delta is
-/// kept; the excess is refunded.
-pub const MINIMUM_ATTESTATION_STORAGE_DEPOSIT: NearToken = NearToken::from_millinear(100);
-
 /// Entries to scan in the post-reshare `clean_invalid_attestations` sweep. External
 /// callers may pick a different value; this only governs the automatic invocation.
 const RESHARE_CLEAN_INVALID_ATTESTATIONS_MAX_SCAN: u32 = 100;
@@ -161,28 +156,23 @@ fn refund_to(account_id: &AccountId, amount: NearToken) {
     }
 }
 
-/// Requires at least [`MINIMUM_ATTESTATION_STORAGE_DEPOSIT`], then keeps the storage delta since
-/// `initial_storage` and refunds the excess.
+/// Charges `account_id` the storage growth since `initial_storage` and refunds the excess. A
+/// participant re-attesting an unchanged entry grows nothing and pays nothing, so the node's
+/// function-call access key can re-attest; a new entry costs the measured delta, funded by the
+/// caller (an operator's full-access key for a first submission).
 fn charge_storage(account_id: &AccountId, initial_storage: u64) -> Result<(), Error> {
+    // saturating_sub: a shrink charges nothing rather than underflowing.
+    let bytes_grown = env::storage_usage().saturating_sub(initial_storage);
+    let cost = env::storage_byte_cost().saturating_mul(u128::from(bytes_grown));
     let attached = env::attached_deposit();
-    if attached < MINIMUM_ATTESTATION_STORAGE_DEPOSIT {
+    if attached < cost {
         return Err(InvalidParameters::InsufficientDeposit {
             attached: attached.as_yoctonear(),
-            required: MINIMUM_ATTESTATION_STORAGE_DEPOSIT.as_yoctonear(),
+            required: cost.as_yoctonear(),
         }
         .into());
     }
-
-    // saturating_sub: a shrink charges nothing rather than underflowing.
-    let bytes_grown = env::storage_usage().saturating_sub(initial_storage);
-    let cost = env::storage_byte_cost().saturating_mul(u128::from(bytes_grown));
-    match attached.checked_sub(cost) {
-        Some(refund) => refund_to(account_id, refund),
-        // Unreachable given the MINIMUM_ATTESTATION_STORAGE_DEPOSIT floor, which
-        // minimum_attestation_storage_deposit__should_cover_worst_case_entry pins to the
-        // worst-case entry cost.
-        None => log!("attestation storage cost {cost} exceeded deposit for {account_id}"),
-    }
+    refund_to(account_id, attached.saturating_sub(cost));
     Ok(())
 }
 
@@ -809,11 +799,11 @@ impl MpcContract {
     ///   callback to run the post-DCAP checks and store the attestation.
     ///
     /// Storage is charged to the caller only when a new entry is stored or the caller is not a
-    /// current participant. A participant re-attesting an existing entry is charged nothing and
-    /// need not attach any deposit, so the node's function-call access key can re-attest. When a
-    /// charge applies, the caller must attach at least [`MINIMUM_ATTESTATION_STORAGE_DEPOSIT`]
-    /// (enough to cover the worst-case stored entry); only the actual storage delta is kept and
-    /// the excess is refunded. The full deposit is refunded if the attestation is not accepted.
+    /// current participant. A participant re-attesting an existing entry grows nothing and is charged
+    /// nothing, so the node's function-call access key can re-attest with no deposit. A new entry
+    /// costs the measured storage delta, which the caller must cover (an operator's full-access key
+    /// funds a first submission); the excess is refunded, as is the full deposit on a rejected
+    /// attestation.
     #[payable]
     #[handle_result]
     pub fn submit_participant_info(
@@ -4674,7 +4664,7 @@ mod tests {
         let context = VMContextBuilder::new()
             .current_account_id(contract_account_id.clone())
             .predecessor_account_id(contract_account_id)
-            .attached_deposit(MINIMUM_ATTESTATION_STORAGE_DEPOSIT)
+            .attached_deposit(NearToken::from_near(1))
             .block_timestamp(VALID_ATTESTATION_TIMESTAMP * 1_000_000_000)
             .build();
         testing_env!(context);
@@ -8139,9 +8129,9 @@ mod tests {
 
     const MAX_HASH: [u8; 32] = [0xff; 32];
 
-    // Catches entry-size growth: fails if a schema change makes the largest storable entry
-    // cost more than the deposit at today's storage_byte_cost. It cannot see a future
-    // storage_byte_cost increase on a live contract; the deposit's margin covers that.
+    // A stored entry a caller must fund stays bounded; a schema change that bloats it fails here.
+    const WORST_CASE_ENTRY_COST_CEILING: NearToken = NearToken::from_millinear(100);
+
     #[rstest]
     #[case::dstack(VerifiedAttestation::Dstack(ValidatedDstackAttestation {
         mpc_image_hash: MAX_HASH.into(),
@@ -8155,7 +8145,7 @@ mod tests {
         expiry_timestamp_seconds: Some(u64::MAX),
         expected_measurements: Some(default_measurements()[0]),
     }))]
-    fn minimum_attestation_storage_deposit__should_cover_worst_case_entry(
+    fn submit_participant_info__should_bound_worst_case_entry_cost(
         #[case] verified_attestation: VerifiedAttestation,
     ) {
         testing_env!(VMContextBuilder::new().build());
@@ -8179,9 +8169,9 @@ mod tests {
         let cost = env::storage_byte_cost().saturating_mul(u128::from(bytes_grown));
 
         assert!(
-            MINIMUM_ATTESTATION_STORAGE_DEPOSIT >= cost,
-            "minimum deposit {MINIMUM_ATTESTATION_STORAGE_DEPOSIT} must cover the worst-case entry \
-             ({bytes_grown} bytes, {cost}) at today's storage price"
+            cost <= WORST_CASE_ENTRY_COST_CEILING,
+            "worst-case entry cost ({bytes_grown} bytes, {cost}) must stay under \
+             {WORST_CASE_ENTRY_COST_CEILING} at today's storage price"
         );
     }
 }

crates/contract/tests/sandbox/tee.rs

@@ -1050,10 +1050,10 @@ async fn verify_tee__should_keep_participants_and_stop_signing_when_kickout_drop
     Ok(())
 }
 
-/// A submission attaching less than the flat storage fee is rejected before the
+/// A new-entry submission attaching less than the measured storage cost is rejected before the
 /// entry is stored.
 #[tokio::test]
-async fn submit_participant_info__should_reject_new_attestation_below_flat_fee() -> Result<()> {
+async fn submit_participant_info__should_reject_new_attestation_below_storage_cost() -> Result<()> {
     // Given
     let SandboxTestSetup {
         worker, contract, ..
@@ -1064,7 +1064,8 @@ async fn submit_participant_info__should_reject_new_attestation_below_flat_fee()
     let outsider = worker.dev_create_account().await?;
     let fresh_tls_key = bogus_ed25519_public_key();
     let storage_before = worker.view_account(contract.id()).await?.storage_usage;
-    let below_fee = SUBMIT_PARTICIPANT_INFO_DEPOSIT.saturating_sub(NearToken::from_yoctonear(1));
+    // 1 yoctoNEAR is below any nonzero entry cost.
+    let below_cost = NearToken::from_yoctonear(1);
 
     // When
     let result = outsider
@@ -1073,15 +1074,15 @@ async fn submit_participant_info__should_reject_new_attestation_below_flat_fee()
             Attestation::Mock(MockAttestation::Valid),
             fresh_tls_key.clone(),
         ))
-        .deposit(below_fee)
+        .deposit(below_cost)
         .max_gas()
         .transact()
         .await?;
 
     // Then
     assert!(
         !result.is_success(),
-        "submission below the flat fee must fail: {result:?}"
+        "submission below the storage cost must fail: {result:?}"
     );
     let error_msg = format!("{:?}", result.into_result());
     assert!(

crates/contract/tests/snapshots/abi__abi_has_not_changed.snap

@@ -2349,7 +2349,7 @@ expression: abi
       },
       {
         "name": "submit_participant_info",
-        "doc": " Submit a TEE attestation for a current or prospective participant.\n\n - [`Attestation::Mock`] is verified synchronously.\n - [`Attestation::Dstack`] is verified asynchronously via a cross-contract\n   `verify_quote` call, with [`Self::resolve_verification`] chained as its\n   callback to run the post-DCAP checks and store the attestation.\n\n Storage is charged to the caller only when a new entry is stored or the caller is not a\n current participant. A participant re-attesting an existing entry is charged nothing and\n need not attach any deposit, so the node's function-call access key can re-attest. When a\n charge applies, the caller must attach at least [`MINIMUM_ATTESTATION_STORAGE_DEPOSIT`]\n (enough to cover the worst-case stored entry); only the actual storage delta is kept and\n the excess is refunded. The full deposit is refunded if the attestation is not accepted.",
+        "doc": " Submit a TEE attestation for a current or prospective participant.\n\n - [`Attestation::Mock`] is verified synchronously.\n - [`Attestation::Dstack`] is verified asynchronously via a cross-contract\n   `verify_quote` call, with [`Self::resolve_verification`] chained as its\n   callback to run the post-DCAP checks and store the attestation.\n\n Storage is charged to the caller only when a new entry is stored or the caller is not a\n current participant. A participant re-attesting an existing entry grows nothing and is charged\n nothing, so the node's function-call access key can re-attest with no deposit. A new entry\n costs the measured storage delta, which the caller must cover (an operator's full-access key\n funds a first submission); the excess is refunded, as is the full deposit on a rejected\n attestation.",
         "kind": "call",
         "modifiers": [
           "payable"

crates/e2e-tests/src/cluster.rs

@@ -49,6 +49,10 @@ pub fn cluster_poll_retry() -> ConstantBuilder {
 }
 
 const NODE_MANAGEMENT_DEPOSIT: near_kit::NearToken = near_kit::NearToken::from_yoctonear(1);
+// Covers a new attestation entry's storage cost; the contract refunds the excess. The contract test
+// submit_participant_info__should_bound_worst_case_entry_cost asserts the worst-case entry stays
+// under this amount.
+const ATTESTATION_STORAGE_DEPOSIT: near_kit::NearToken = near_kit::NearToken::from_millinear(100);
 // The contract's default `key_event_timeout_blocks = 30` is ~18 s on
 // mainnet (~600 ms blocks). The e2e sandbox runs ~8 blocks/s, so the
 // same 30 collapses to ~3.7 s — too tight for the resharing
@@ -559,6 +563,8 @@ impl MpcCluster {
         new_participants: &[usize],
         new_threshold: usize,
     ) -> anyhow::Result<()> {
+        self.fund_new_participant_attestations(new_participants)
+            .await?;
         self.wait_for_participant_attestations(new_participants)
             .await?;
 
@@ -611,6 +617,42 @@ impl MpcCluster {
         .map(|_| ())
     }
 
+    /// Submit each new participant's first attestation with a deposit covering the new entry's
+    /// storage cost, which the node's own function-call key cannot attach on-chain. Signed with the
+    /// node's near_signer_key so the stored account_public_key matches the key it later signs
+    /// key-event votes with. Idempotent: the node's later self-submit of the same entry is free.
+    async fn fund_new_participant_attestations(
+        &self,
+        node_indices: &[usize],
+    ) -> anyhow::Result<()> {
+        for &idx in node_indices {
+            let node = &self.nodes[idx];
+            let client = self
+                .blockchain
+                .client_for(node.account_id().as_ref(), node.near_signer_key())?;
+            let pubkey = node.p2p_public_key();
+            let outcome = self
+                .contract
+                .call_from_deposit(
+                    &client,
+                    method_names::SUBMIT_PARTICIPANT_INFO,
+                    json!({
+                        "proposed_participant_attestation": Attestation::Mock(MockAttestation::Valid),
+                        "tls_public_key": pubkey,
+                    }),
+                    ATTESTATION_STORAGE_DEPOSIT,
+                )
+                .await
+                .with_context(|| format!("failed to fund attestation for node {idx}"))?;
+            anyhow::ensure!(
+                outcome.is_success(),
+                "funding attestation for node {idx} reverted: {:?}",
+                outcome.failure_message()
+            );
+        }
+        Ok(())
+    }
+
     /// Poll until all proposed participants have TEE attestations on-chain.
     async fn wait_for_participant_attestations(
         &self,
@@ -1182,6 +1224,13 @@ impl MpcNodeState {
         }
     }
 
+    pub fn near_signer_key(&self) -> &SigningKey {
+        match self {
+            MpcNodeState::Running(n) => n.setup().near_signer_key(),
+            MpcNodeState::Stopped(s) => s.near_signer_key(),
+        }
+    }
+
     pub fn p2p_public_key_str(&self) -> String {
         String::from(&self.p2p_public_key())
     }