refactor(interface): FunctionCallArgs constructors

FunctionCallArgs::new and ::no_deposit mirror ViewArgs::new/no_args;
every handle method builds its call through them and a shared private
call(), replacing the struct literals and the call_without_deposit
helper. No wire change — the snapshot catalog is untouched.

Author: kevindeforth

crates/near-contract-transport/src/types.rs

@@ -12,6 +12,26 @@ pub struct FunctionCallArgs {
     pub deposit: NearToken,
 }
 
+impl FunctionCallArgs {
+    pub fn new(
+        method_name: impl Into<String>,
+        args: Vec<u8>,
+        gas: NearGas,
+        deposit: NearToken,
+    ) -> Self {
+        Self {
+            method_name: method_name.into(),
+            args,
+            gas,
+            deposit,
+        }
+    }
+
+    pub fn no_deposit(method_name: impl Into<String>, args: Vec<u8>, gas: NearGas) -> Self {
+        Self::new(method_name, args, gas, NearToken::from_yoctonear(0))
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ViewArgs {
     pub method_name: String,

crates/near-mpc-contract-interface/src/client.rs

@@ -66,18 +66,13 @@ impl<C: CallContract> MpcContractHandle<C> {
         request: SignRequestArgs,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&SignArgs::new(request))?;
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: SIGN.to_string(),
-                    args,
-                    gas: SIGN_GAS,
-                    deposit: NearToken::from_yoctonear(SIGN_DEPOSIT_YOCTONEAR),
-                },
-            )
-            .await
-            .map_err(MpcContractHandleError::Call)
+        self.call(FunctionCallArgs::new(
+            SIGN,
+            args,
+            SIGN_GAS,
+            NearToken::from_yoctonear(SIGN_DEPOSIT_YOCTONEAR),
+        ))
+        .await
     }
 
     pub async fn request_app_private_key(
@@ -89,37 +84,27 @@ impl<C: CallContract> MpcContractHandle<C> {
             CKDAppPublicKey::AppPublicKeyPV(_) => CKD_PV_GAS,
         };
         let args = serde_json::to_vec(&RequestAppPrivateKeyArgs::new(request))?;
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: REQUEST_APP_PRIVATE_KEY.to_string(),
-                    args,
-                    gas,
-                    deposit: NearToken::from_yoctonear(SIGN_DEPOSIT_YOCTONEAR),
-                },
-            )
-            .await
-            .map_err(MpcContractHandleError::Call)
+        self.call(FunctionCallArgs::new(
+            REQUEST_APP_PRIVATE_KEY,
+            args,
+            gas,
+            NearToken::from_yoctonear(SIGN_DEPOSIT_YOCTONEAR),
+        ))
+        .await
     }
 
     pub async fn verify_foreign_transaction(
         &self,
         request: VerifyForeignTransactionRequestArgs,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&VerifyForeignTransactionArgs::new(request))?;
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: VERIFY_FOREIGN_TRANSACTION.to_string(),
-                    args,
-                    gas: SIGN_GAS,
-                    deposit: NearToken::from_yoctonear(SIGN_DEPOSIT_YOCTONEAR),
-                },
-            )
-            .await
-            .map_err(MpcContractHandleError::Call)
+        self.call(FunctionCallArgs::new(
+            VERIFY_FOREIGN_TRANSACTION,
+            args,
+            SIGN_GAS,
+            NearToken::from_yoctonear(SIGN_DEPOSIT_YOCTONEAR),
+        ))
+        .await
     }
 
     pub async fn propose_update(
@@ -135,46 +120,35 @@ impl<C: CallContract> MpcContractHandle<C> {
             STORAGE_BYTE_COST_YOCTONEAR,
         )?);
         let args = borsh::to_vec(&args)?;
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: PROPOSE_UPDATE.to_string(),
-                    args,
-                    gas: MAX_GAS,
-                    deposit,
-                },
-            )
-            .await
-            .map_err(MpcContractHandleError::Call)
+        self.call(FunctionCallArgs::new(
+            PROPOSE_UPDATE,
+            args,
+            MAX_GAS,
+            deposit,
+        ))
+        .await
     }
 
     pub async fn vote_update(
         &self,
         id: u64,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&VoteUpdateArgs::new(id))?;
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: VOTE_UPDATE.to_string(),
-                    args,
-                    gas: MAX_GAS,
-                    deposit: NearToken::from_yoctonear(0),
-                },
-            )
+        self.call(FunctionCallArgs::no_deposit(VOTE_UPDATE, args, MAX_GAS))
             .await
-            .map_err(MpcContractHandleError::Call)
     }
 
     pub async fn vote_add_domains(
         &self,
         domains: Vec<DomainConfig>,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&VoteAddDomainsArgs::new(domains))?;
-        self.call_without_deposit(VOTE_ADD_DOMAINS, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            VOTE_ADD_DOMAINS,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn vote_new_parameters(
@@ -183,51 +157,75 @@ impl<C: CallContract> MpcContractHandle<C> {
         proposal: ProposedGovernanceThresholdParameters,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&VoteNewParametersArgs::new(prospective_epoch_id, proposal))?;
-        self.call_without_deposit(VOTE_NEW_PARAMETERS, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            VOTE_NEW_PARAMETERS,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn vote_cancel_keygen(
         &self,
         next_domain_id: u64,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&VoteCancelKeygenArgs::new(next_domain_id))?;
-        self.call_without_deposit(VOTE_CANCEL_KEYGEN, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            VOTE_CANCEL_KEYGEN,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn vote_cancel_resharing(
         &self,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
-        self.call_without_deposit(VOTE_CANCEL_RESHARING, b"{}".to_vec(), MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            VOTE_CANCEL_RESHARING,
+            b"{}".to_vec(),
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn update_participant_url(
         &self,
         url: String,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&UpdateParticipantUrlArgs::new(url))?;
-        self.call_without_deposit(UPDATE_PARTICIPANT_URL, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            UPDATE_PARTICIPANT_URL,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn register_backup_service(
         &self,
         backup_service_info: BackupServiceInfo,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&RegisterBackupServiceArgs::new(backup_service_info))?;
-        self.call_without_deposit(REGISTER_BACKUP_SERVICE, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            REGISTER_BACKUP_SERVICE,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn start_node_migration(
         &self,
         destination_node_info: DestinationNodeInfo,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = serde_json::to_vec(&StartNodeMigrationArgs::new(destination_node_info))?;
-        self.call_without_deposit(START_NODE_MIGRATION, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            START_NODE_MIGRATION,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn register_foreign_chain_support(
@@ -236,40 +234,33 @@ impl<C: CallContract> MpcContractHandle<C> {
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args =
             serde_json::to_vec(&RegisterForeignChainSupportArgs::new(foreign_chain_support))?;
-        self.call_without_deposit(REGISTER_FOREIGN_CHAIN_SUPPORT, args, MAX_GAS)
-            .await
+        self.call(FunctionCallArgs::no_deposit(
+            REGISTER_FOREIGN_CHAIN_SUPPORT,
+            args,
+            MAX_GAS,
+        ))
+        .await
     }
 
     pub async fn vote_update_foreign_chain_providers(
         &self,
         batch: NonEmptyBTreeMap<ForeignChain, ChainEntry>,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         let args = borsh::to_vec(&batch)?;
-        self.call_without_deposit(
+        self.call(FunctionCallArgs::no_deposit(
             VOTE_UPDATE_FOREIGN_CHAIN_PROVIDERS,
             args,
             VOTE_FOREIGN_CHAIN_GAS,
-        )
+        ))
         .await
     }
 
-    /// Zero-deposit call with pre-encoded args.
-    async fn call_without_deposit(
+    async fn call(
         &self,
-        method_name: &str,
-        args: Vec<u8>,
-        gas: NearGas,
+        call_args: FunctionCallArgs,
     ) -> Result<C::Output, MpcContractHandleError<C::Error>> {
         self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: method_name.to_string(),
-                    args,
-                    gas,
-                    deposit: NearToken::from_yoctonear(0),
-                },
-            )
+            .call_contract(&self.contract_id, call_args)
             .await
             .map_err(MpcContractHandleError::Call)
     }
@@ -283,33 +274,22 @@ impl<C: CallContract> MpcContractHandle<C> {
             proposed_participant_attestation,
             tls_public_key,
         ))?;
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: SUBMIT_PARTICIPANT_INFO.to_string(),
-                    args,
-                    gas: MAX_GAS,
-                    deposit: NearToken::from_millinear(SUBMIT_PARTICIPANT_INFO_DEPOSIT_MILLINEAR),
-                },
-            )
-            .await
-            .map_err(MpcContractHandleError::Call)
+        self.call(FunctionCallArgs::new(
+            SUBMIT_PARTICIPANT_INFO,
+            args,
+            MAX_GAS,
+            NearToken::from_millinear(SUBMIT_PARTICIPANT_INFO_DEPOSIT_MILLINEAR),
+        ))
+        .await
     }
 
     pub async fn verify_tee(&self) -> Result<C::Output, MpcContractHandleError<C::Error>> {
-        self.caller
-            .call_contract(
-                &self.contract_id,
-                FunctionCallArgs {
-                    method_name: VERIFY_TEE.to_string(),
-                    args: b"{}".to_vec(),
-                    gas: MAX_GAS,
-                    deposit: NearToken::from_yoctonear(0),
-                },
-            )
-            .await
-            .map_err(MpcContractHandleError::Call)
+        self.call(FunctionCallArgs::no_deposit(
+            VERIFY_TEE,
+            b"{}".to_vec(),
+            MAX_GAS,
+        ))
+        .await
     }
 }