refactor(sandbox): use mpc contract interface

crates/contract/tests/sandbox/common.rs

@@ -1,10 +1,11 @@
 use crate::sandbox::utils::{
-    consts::{CURRENT_CONTRACT_DEPLOY_DEPOSIT, GAS_FOR_INIT, GAS_FOR_VOTE_UPDATE, PARTICIPANT_LEN},
+    consts::{GAS_FOR_INIT, PARTICIPANT_LEN},
     contract_build::current_contract,
     initializing_utils::{start_keygen_instance, vote_add_domains, vote_public_key},
     mpc_contract::{assert_running_return_threshold, get_state, submit_participant_info},
     shared_key_utils::{DomainKey, make_key_for_domain},
     sign_utils::{PendingSignRequest, make_and_submit_requests},
+    transactions::SandboxCaller,
 };
 use digest::Digest;
 use dtos::ProtocolContractState;
@@ -32,6 +33,7 @@ use near_mpc_contract_interface::types::{
     TonExtractor, TonFinality, TonLog, TonRpcRequest, TonTxId,
 };
 use near_mpc_contract_interface::{
+    client::MpcContractHandle,
     method_names,
     types::{
         self as dtos, Attestation, BitcoinExtractedValue, BitcoinExtractor, BitcoinRpcRequest,
@@ -350,17 +352,14 @@ pub async fn propose_and_vote_contract_binary(
     contract: &Contract,
     new_contract_binary: &[u8],
 ) {
-    let propose_update_execution = accounts[0]
-        .call(contract.id(), method_names::PROPOSE_UPDATE)
-        .args_borsh(ProposeUpdateArgs {
-            code: Some(new_contract_binary.to_vec()),
-            config: None,
-        })
-        .max_gas()
-        .deposit(CURRENT_CONTRACT_DEPLOY_DEPOSIT)
-        .transact()
-        .await
-        .expect("propose update call succeeds");
+    let propose_update_execution =
+        MpcContractHandle::new(SandboxCaller(&accounts[0]), contract.id().clone())
+            .propose_update(ProposeUpdateArgs {
+                code: Some(new_contract_binary.to_vec()),
+                config: None,
+            })
+            .await
+            .expect("propose update call succeeds");
 
     assert!(
         propose_update_execution.is_success(),
@@ -396,13 +395,8 @@ pub async fn vote_update_till_completion(
     proposal_id: &UpdateId,
 ) {
     for voter in accounts {
-        let execution = voter
-            .call(contract.id(), method_names::VOTE_UPDATE)
-            .args_json(serde_json::json!({
-                "id": proposal_id,
-            }))
-            .gas(GAS_FOR_VOTE_UPDATE)
-            .transact()
+        let execution = MpcContractHandle::new(SandboxCaller(voter), contract.id().clone())
+            .vote_update(**proposal_id)
             .await
             .unwrap();
 
@@ -597,18 +591,10 @@ pub async fn execute_key_generation_and_add_random_state(
     let dummy_threshold_parameters =
         GovernanceThresholdParameters::new(participants, GovernanceThreshold::new(threshold.0 + 1))
             .unwrap();
-    let dummy_proposal = json!({
-        "prospective_epoch_id": 1,
-        "proposal": ProposedGovernanceThresholdParameters::new(
-            dummy_threshold_parameters,
-            BTreeMap::new(),
-        ),
-    });
-    accounts[0]
-        .call(contract.id(), method_names::VOTE_NEW_PARAMETERS)
-        .args_json(dummy_proposal)
-        .max_gas()
-        .transact()
+    let dummy_proposal =
+        ProposedGovernanceThresholdParameters::new(dummy_threshold_parameters, BTreeMap::new());
+    MpcContractHandle::new(SandboxCaller(&accounts[0]), contract.id().clone())
+        .vote_new_parameters(dtos::EpochId::new(1), dummy_proposal.into())
         .await
         .unwrap()
         .unwrap();
@@ -661,10 +647,8 @@ pub async fn register_foreign_chain_configuration(
 ) {
     let node_foreign_chain_support = SupportedForeignChains::from(BTreeSet::from([chain]));
     for account in accounts {
-        let result = account
-            .call(contract.id(), method_names::REGISTER_FOREIGN_CHAIN_SUPPORT)
-            .args_json(json!({ "foreign_chain_support": node_foreign_chain_support }))
-            .transact()
+        let result = MpcContractHandle::new(SandboxCaller(account), contract.id().clone())
+            .register_foreign_chain_support(node_foreign_chain_support.clone())
             .await
             .unwrap()
             .into_result();

crates/contract/tests/sandbox/contract_configuration.rs

@@ -1,9 +1,9 @@
 use crate::sandbox::{
-    common::SandboxTestSetup,
-    upgrade_from_current_contract::current_contract_proposal,
-    utils::consts::{CURRENT_CONTRACT_DEPLOY_DEPOSIT, GAS_FOR_VOTE_UPDATE},
+    common::SandboxTestSetup, upgrade_from_current_contract::current_contract_proposal,
+    utils::transactions::SandboxCaller,
 };
 use mpc_contract::update::UpdateId;
+use near_mpc_contract_interface::client::MpcContractHandle;
 use near_mpc_contract_interface::method_names;
 
 #[tokio::test]
@@ -44,14 +44,13 @@ async fn run_upgrade_scenario(min_gas: u64) -> (bool, bool) {
         .build()
         .await;
 
-    let execution = mpc_signer_accounts[0]
-        .call(contract.id(), method_names::PROPOSE_UPDATE)
-        .args_borsh(current_contract_proposal())
-        .max_gas()
-        .deposit(CURRENT_CONTRACT_DEPLOY_DEPOSIT)
-        .transact()
-        .await
-        .unwrap();
+    let execution = MpcContractHandle::new(
+        SandboxCaller(&mpc_signer_accounts[0]),
+        contract.id().clone(),
+    )
+    .propose_update(current_contract_proposal())
+    .await
+    .unwrap();
 
     assert!(execution.is_success());
     let proposal_id: UpdateId = execution.json().unwrap();
@@ -60,11 +59,8 @@ async fn run_upgrade_scenario(min_gas: u64) -> (bool, bool) {
     let mut saw_failure = false;
 
     for voter in mpc_signer_accounts {
-        let execution = voter
-            .call(contract.id(), method_names::VOTE_UPDATE)
-            .args_json(serde_json::json!({ "id": proposal_id }))
-            .gas(GAS_FOR_VOTE_UPDATE)
-            .transact()
+        let execution = MpcContractHandle::new(SandboxCaller(&voter), contract.id().clone())
+            .vote_update(*proposal_id)
             .await
             .unwrap();
 

crates/contract/tests/sandbox/foreign_chain_request.rs

@@ -8,12 +8,13 @@ use crate::sandbox::common::{
     register_foreign_chain_configuration, sign_foreign_tx_response, starknet_extracted_values,
     starknet_request, sui_extracted_values, sui_request, ton_request,
 };
+use crate::sandbox::utils::transactions::{AsyncSandboxCaller, SandboxCaller};
+use near_mpc_contract_interface::client::MpcContractHandle;
 use near_mpc_contract_interface::method_names;
 use near_mpc_contract_interface::types::{
     self as dtos, ExtractedValue, ForeignChainRpcRequest, ForeignTxPayloadVersion,
     VerifyForeignTransactionRequest, VerifyForeignTransactionResponse,
 };
-use near_workspaces::types::NearToken;
 use rstest::rstest;
 use serde_json::json;
 
@@ -54,15 +55,8 @@ async fn verify_foreign_transaction__should_succeed(
         request: rpc_request.clone(),
     };
 
-    let status = user
-        .call(
-            setup.contract.id(),
-            method_names::VERIFY_FOREIGN_TRANSACTION,
-        )
-        .args_json(json!({ "request": request_args }))
-        .deposit(NearToken::from_yoctonear(1))
-        .max_gas()
-        .transact_async()
+    let status = MpcContractHandle::new(AsyncSandboxCaller(&user), setup.contract.id().clone())
+        .verify_foreign_transaction(request_args.clone())
         .await
         .unwrap();
 
@@ -131,26 +125,13 @@ async fn verify_foreign_transaction__should_fan_out_response_to_duplicates_from_
     };
 
     // When
-    let status_alice = alice
-        .call(
-            setup.contract.id(),
-            method_names::VERIFY_FOREIGN_TRANSACTION,
-        )
-        .args_json(json!({ "request": request_args }))
-        .deposit(NearToken::from_yoctonear(1))
-        .max_gas()
-        .transact_async()
-        .await
-        .unwrap();
-    let status_bob = bob
-        .call(
-            setup.contract.id(),
-            method_names::VERIFY_FOREIGN_TRANSACTION,
-        )
-        .args_json(json!({ "request": request_args }))
-        .deposit(NearToken::from_yoctonear(1))
-        .max_gas()
-        .transact_async()
+    let status_alice =
+        MpcContractHandle::new(AsyncSandboxCaller(&alice), setup.contract.id().clone())
+            .verify_foreign_transaction(request_args.clone())
+            .await
+            .unwrap();
+    let status_bob = MpcContractHandle::new(AsyncSandboxCaller(&bob), setup.contract.id().clone())
+        .verify_foreign_transaction(request_args.clone())
         .await
         .unwrap();
     await_pending_foreign_tx_request_observed_on_contract(&setup.contract, &verify_request).await;
@@ -224,15 +205,8 @@ async fn verify_foreign_transaction__should_reject_without_policy(
         request: rpc_request,
     };
 
-    let result = user
-        .call(
-            setup.contract.id(),
-            method_names::VERIFY_FOREIGN_TRANSACTION,
-        )
-        .args_json(json!({ "request": request_args }))
-        .deposit(NearToken::from_yoctonear(1))
-        .max_gas()
-        .transact()
+    let result = MpcContractHandle::new(SandboxCaller(&user), setup.contract.id().clone())
+        .verify_foreign_transaction(request_args.clone())
         .await
         .unwrap()
         .into_result();
@@ -276,15 +250,8 @@ async fn verify_foreign_transaction__should_timeout_without_response(
         request: rpc_request,
     };
 
-    let status = user
-        .call(
-            setup.contract.id(),
-            method_names::VERIFY_FOREIGN_TRANSACTION,
-        )
-        .args_json(json!({ "request": request_args }))
-        .deposit(NearToken::from_yoctonear(1))
-        .max_gas()
-        .transact_async()
+    let status = MpcContractHandle::new(AsyncSandboxCaller(&user), setup.contract.id().clone())
+        .verify_foreign_transaction(request_args.clone())
         .await
         .unwrap();
 

crates/contract/tests/sandbox/tee.rs

@@ -12,14 +12,15 @@ use crate::sandbox::{
         },
         resharing_utils::conclude_resharing,
         sign_utils::DomainResponseTest,
+        transactions::SandboxCaller,
     },
 };
 use anyhow::Result;
 use mpc_contract::primitives::{participants::Participants, test_utils::bogus_ed25519_public_key};
 use mpc_primitives::hash::{LauncherDockerComposeHash, LauncherImageHash, NodeImageHash};
-use near_mpc_contract_interface::method_names;
 use near_mpc_contract_interface::types::Protocol;
 use near_mpc_contract_interface::types::{self as dtos, Attestation, MockAttestation};
+use near_mpc_contract_interface::{client::MpcContractHandle, method_names};
 use near_workspaces::Contract;
 use near_workspaces::types::NearToken;
 use rand::SeedableRng;
@@ -795,12 +796,12 @@ async fn test_verify_tee_expired_attestation_triggers_resharing() -> Result<()>
     );
 
     // Call verify_tee() to trigger resharing
-    let verify_result = mpc_signer_accounts[0]
-        .call(contract.id(), method_names::VERIFY_TEE)
-        .args_json(serde_json::json!({}))
-        .max_gas()
-        .transact()
-        .await?;
+    let verify_result = MpcContractHandle::new(
+        SandboxCaller(&mpc_signer_accounts[0]),
+        contract.id().clone(),
+    )
+    .verify_tee()
+    .await?;
     dbg!(&verify_result);
     assert!(
         verify_result.is_success(),
@@ -922,12 +923,12 @@ async fn verify_tee__should_keep_participants_and_stop_signing_when_kickout_drop
     );
 
     // When: a participant calls verify_tee while too few valid attestations remain.
-    let verify_result = mpc_signer_accounts[0]
-        .call(contract.id(), method_names::VERIFY_TEE)
-        .args_json(serde_json::json!({}))
-        .max_gas()
-        .transact()
-        .await?;
+    let verify_result = MpcContractHandle::new(
+        SandboxCaller(&mpc_signer_accounts[0]),
+        contract.id().clone(),
+    )
+    .verify_tee()
+    .await?;
     assert!(
         verify_result.is_success(),
         "verify_tee call failed: {verify_result:?}"
@@ -961,13 +962,8 @@ async fn verify_tee__should_keep_participants_and_stop_signing_when_kickout_drop
     ) else {
         panic!("CaitSith domain must yield a sign request");
     };
-    let sign_result = requester
-        .call(contract.id(), method_names::SIGN)
-        .args_json(sign_request.request_json_args())
-        .deposit(NearToken::from_yoctonear(1))
-        .max_gas()
-        .transact()
-        .await?;
+    let contract_handle = MpcContractHandle::new(SandboxCaller(requester), contract.id().clone());
+    let sign_result = contract_handle.sign(sign_request.args).await?;
     let Err(sign_err) = sign_result.into_result() else {
         panic!("sign request must be refused while the network is not accepting requests");
     };