feat: add missing self call methods

res/mock_evm/src/lib.rs

@@ -64,4 +64,26 @@ impl MockEvmContract {
     pub fn register_relayer(&mut self, #[serializer(borsh)] input: Raw) {
         assert_eq!(input.0.len(), 20);
     }
+
+    //
+    // SELF CALL METHODS
+    //
+
+    pub fn set_eth_connector_contract_data(&mut self, #[serializer(borsh)] _input: Raw) {}
+
+    pub fn set_paused_flags(&mut self, #[serializer(borsh)] _input: Raw) {}
+
+    //
+    // CALLBACK HANDLER METHODS
+    //
+
+    #[result_serializer(borsh)]
+    pub fn factory_update_address_version(&mut self, #[serializer(borsh)] _input: Raw) -> u8 {
+        0
+    }
+
+    #[result_serializer(borsh)]
+    pub fn refund_on_error(&mut self, #[serializer(borsh)] _input: Raw) -> u8 {
+        0
+    }
 }

workspace/src/contract.rs

@@ -1,15 +1,20 @@
 use crate::operation::{
-    Call, CallDeployCode, CallDeployErc20, CallEvm, CallFtOnTransfer, CallFtTransfer,
-    CallFtTransferCall, CallRegisterRelayer, CallStorageDeposit, CallStorageUnregister,
-    CallStorageWithdraw, CallSubmit, View, ViewResultDetails,
+    Call, CallDeployCode, CallDeployErc20, CallEvm, CallFactoryUpdateAddressVersion,
+    CallFtOnTransfer, CallFtTransfer, CallFtTransferCall, CallRefundOnError, CallRegisterRelayer,
+    CallSetEthConnectorContractData, CallSetPausedFlags, CallStorageDeposit, CallStorageUnregister,
+    CallStorageWithdraw, CallSubmit, SelfCall, View, ViewResultDetails,
 };
 #[cfg(feature = "deposit-withdraw")]
 use crate::operation::{CallDeposit, CallWithdraw};
 use crate::{EngineCallTransaction, Result};
-use aurora_engine::parameters::ViewCallArgs;
-use aurora_engine::parameters::{
-    GetStorageAtArgs, StorageBalance, StorageDepositCallArgs, StorageWithdrawCallArgs,
-    TransactionStatus, TransferCallArgs,
+use aurora_engine::fungible_token::FungibleTokenMetadata;
+use aurora_engine::{
+    parameters::{
+        GetStorageAtArgs, PauseEthConnectorCallArgs, SetContractDataCallArgs, StorageBalance,
+        StorageDepositCallArgs, StorageWithdrawCallArgs, TransactionStatus, TransferCallArgs,
+        ViewCallArgs,
+    },
+    xcc::AddressVersionUpdateArgs,
 };
 use aurora_workspace_types::input::IsUsedProofCallArgs;
 use aurora_workspace_types::input::ProofInput;
@@ -20,7 +25,6 @@ use aurora_workspace_types::{AccountId, Address, Raw, H256, U256};
 use borsh::BorshSerialize;
 #[cfg(feature = "ethabi")]
 use ethabi::{ParamType, Token};
-use near_contract_standards::fungible_token::metadata::FungibleTokenMetadata;
 use near_sdk::json_types::U128;
 use serde_json::json;
 use std::borrow::{Borrow, BorrowMut};
@@ -190,6 +194,64 @@ impl<U: UserFunctions> EvmAccount<U> {
         self.account.id()
     }
 
+    pub fn set_eth_connector_contract_data(
+        &self,
+        prover_account: impl AsRef<str>,
+        eth_custodian_address: impl Into<String>,
+        metadata: FungibleTokenMetadata,
+    ) -> CallSetEthConnectorContractData<'_> {
+        let args = SetContractDataCallArgs {
+            prover_account: aurora_engine_types::account_id::AccountId::new(
+                prover_account.as_ref(),
+            )
+            .unwrap(),
+            eth_custodian_address: eth_custodian_address.into(),
+            metadata,
+        };
+        CallSetEthConnectorContractData(
+            self.near_call(&SelfCall::SetEthConnectorContractData)
+                .args_borsh(args),
+        )
+    }
+
+    pub fn set_paused_flags(&self, paused_mask: u8) -> CallSetPausedFlags<'_> {
+        let args = PauseEthConnectorCallArgs { paused_mask };
+        CallSetPausedFlags(self.near_call(&SelfCall::SetPausedFlags).args_borsh(args))
+    }
+
+    pub fn factory_update_address_version(
+        &self,
+        address: impl Into<Address>,
+        version: u32,
+    ) -> CallFactoryUpdateAddressVersion<'_> {
+        let args = AddressVersionUpdateArgs {
+            address: aurora_engine_types::types::Address::new(address.into()),
+            version: aurora_engine::xcc::CodeVersion(version),
+        };
+        CallFactoryUpdateAddressVersion(
+            self.near_call(&SelfCall::FactoryUpdateAddressVersion)
+                .args_borsh(args),
+        )
+    }
+
+    pub fn refund_on_error<A: Into<Address>>(
+        &self,
+        recipient_address: A,
+        erc20_address: Option<A>,
+        amount: U256,
+    ) -> CallRefundOnError<'_> {
+        let mut raw_amount: aurora_engine_types::types::RawU256 = Default::default();
+        amount.to_big_endian(&mut raw_amount);
+        let args = aurora_engine_types::parameters::RefundCallArgs {
+            recipient_address: aurora_engine_types::types::Address::new(recipient_address.into()),
+            erc20_address: erc20_address
+                .map(Into::into)
+                .map(aurora_engine_types::types::Address::new),
+            amount: raw_amount,
+        };
+        CallRefundOnError(self.near_call(&SelfCall::RefundOnError).args_borsh(args))
+    }
+
     /// Deploys contract code using the caller's NEAR account ID as an Ethereum address.
     ///
     /// The logic which creates the ETH address is as follows:

workspace/src/operation.rs

@@ -3,23 +3,25 @@ use crate::error::Error;
 use crate::result::ExecutionSuccess;
 use crate::types::output::SubmitResult;
 use crate::Result;
+use aurora_engine::fungible_token::FungibleTokenMetadata;
 #[cfg(feature = "deposit-withdraw")]
 use aurora_engine::parameters::WithdrawResult;
 use aurora_engine::parameters::{StorageBalance, TransactionStatus};
+#[cfg(feature = "deposit-withdraw")]
+use aurora_engine_sdk::promise::PromiseId;
 use aurora_engine_types::types::Wei;
 use aurora_workspace_types::AccountId;
 use borsh::BorshDeserialize;
 #[cfg(feature = "ethabi")]
 use ethabi::{ParamType, Token};
 use ethereum_types::{Address, H256, U256};
-use near_contract_standards::fungible_token::metadata::FungibleTokenMetadata;
 use near_sdk::json_types::U128;
 use near_sdk::PromiseOrValue;
 use workspaces::operations::CallTransaction;
 use workspaces::result::ExecutionFinalResult;
 
 macro_rules! impl_call_return  {
-    ($(($name:ident, $return:ty, $fun:ident)),*) => {
+    ($(($name:ident, $return:ty, $deser_fn:ident)),* $(,)?) => {
         $(pub struct $name<'a>(pub(crate) EngineCallTransaction<'a>);
 
         impl<'a> $name<'a> {
@@ -39,7 +41,7 @@ macro_rules! impl_call_return  {
             }
 
             pub async fn transact(self) -> Result<$return> {
-                ExecutionSuccess::$fun(self.0.transact().await?)
+                ExecutionSuccess::$deser_fn(self.0.transact().await?)
             }
         })*
     }
@@ -64,7 +66,19 @@ impl_call_return![
     ),
     (CallStorageDeposit, ExecutionSuccess<()>, try_from),
     (CallStorageUnregister, ExecutionSuccess<()>, try_from),
-    (CallStorageWithdraw, ExecutionSuccess<()>, try_from)
+    (CallStorageWithdraw, ExecutionSuccess<()>, try_from),
+    (
+        CallSetEthConnectorContractData,
+        ExecutionSuccess<()>,
+        try_from_borsh
+    ),
+    (CallSetPausedFlags, ExecutionSuccess<()>, try_from_borsh),
+    (
+        CallFactoryUpdateAddressVersion,
+        ExecutionSuccess<u8>,
+        try_from_borsh
+    ),
+    (CallRefundOnError, ExecutionSuccess<u8>, try_from_borsh),
 ];
 
 #[cfg(feature = "deposit-withdraw")]
@@ -322,10 +336,10 @@ pub enum View {
     EthTotalSupply,
     FtMetadata,
     StorageBalanceOf,
-    PausedFlags,     // TODO
+    PausedFlags,
     AccountsCounter, // TODO
-    Erc20FromNep141, // TODO
-    Nep141FromErc20, // TODO
+    Erc20FromNep141,
+    Nep141FromErc20,
 }
 
 impl AsRef<str> for View {
@@ -401,25 +415,19 @@ impl AsRef<str> for OwnerCall {
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum SelfCall {
-    NewEthConnector,
     SetEthConnectorContractData,
     FactoryUpdateAddressVersion,
     RefundOnError,
-    FinishDeposit,
-    FtResolveTransfer,
     SetPausedFlags,
 }
 
 impl AsRef<str> for SelfCall {
     fn as_ref(&self) -> &str {
         use SelfCall::*;
         match self {
-            NewEthConnector => "new_eth_connector",
             SetEthConnectorContractData => "set_eth_connector_contract_data",
             FactoryUpdateAddressVersion => "factory_update_address_version",
             RefundOnError => "refund_on_error",
-            FinishDeposit => "finish_deposit",
-            FtResolveTransfer => "resolve_transfer",
             SetPausedFlags => "set_paused_flags",
         }
     }

workspace/tests/self_call_tests.rs

@@ -0,0 +1,52 @@
+use aurora_engine::fungible_token::FungibleTokenMetadata;
+use aurora_workspace_types::Address;
+
+mod common;
+
+#[tokio::test]
+async fn test_set_eth_connector_contract_data() {
+    let contract = common::init_and_deploy_contract().await.unwrap();
+
+    contract
+        .as_account()
+        .set_eth_connector_contract_data(
+            "prover.test.near",
+            "custodian.test.near",
+            FungibleTokenMetadata::default(),
+        )
+        .transact()
+        .await
+        .unwrap();
+}
+
+#[tokio::test]
+async fn test_factory_update_address_version() {
+    let contract = common::init_and_deploy_contract().await.unwrap();
+
+    let res = contract
+        .as_account()
+        .factory_update_address_version(Address::default(), 0)
+        .transact()
+        .await
+        .unwrap()
+        .into_value();
+
+    let expected = 0;
+    assert_eq!(expected, res);
+}
+
+#[tokio::test]
+async fn test_refund_on_error() {
+    let contract = common::init_and_deploy_contract().await.unwrap();
+
+    let res = contract
+        .as_account()
+        .refund_on_error(Address::default(), Some(Address::default()), 0.into())
+        .transact()
+        .await
+        .unwrap()
+        .into_value();
+
+    let expected = 0;
+    assert_eq!(expected, res);
+}