From da1305afeb0fc3b71e55d367b3236958d0fcffe1 Mon Sep 17 00:00:00 2001 From: mandreyel Date: Fri, 3 Mar 2023 11:27:54 +0100 Subject: [PATCH] feat: add missing self call methods --- res/mock_evm/src/lib.rs | 22 +++++++++ workspace/src/contract.rs | 78 +++++++++++++++++++++++++++--- workspace/src/operation.rs | 34 ++++++++----- workspace/tests/self_call_tests.rs | 52 ++++++++++++++++++++ 4 files changed, 165 insertions(+), 21 deletions(-) create mode 100644 workspace/tests/self_call_tests.rs diff --git a/res/mock_evm/src/lib.rs b/res/mock_evm/src/lib.rs index 485f781..8de25f9 100644 --- a/res/mock_evm/src/lib.rs +++ b/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 + } } diff --git a/workspace/src/contract.rs b/workspace/src/contract.rs index b5cf868..6d6951c 100644 --- a/workspace/src/contract.rs +++ b/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 EvmAccount { self.account.id() } + pub fn set_eth_connector_contract_data( + &self, + prover_account: impl AsRef, + eth_custodian_address: impl Into, + 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
, + 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>( + &self, + recipient_address: A, + erc20_address: Option, + 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: diff --git a/workspace/src/operation.rs b/workspace/src/operation.rs index 0c56275..a8954de 100644 --- a/workspace/src/operation.rs +++ b/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, + try_from_borsh + ), + (CallRefundOnError, ExecutionSuccess, 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 for View { @@ -401,12 +415,9 @@ impl AsRef for OwnerCall { #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum SelfCall { - NewEthConnector, SetEthConnectorContractData, FactoryUpdateAddressVersion, RefundOnError, - FinishDeposit, - FtResolveTransfer, SetPausedFlags, } @@ -414,12 +425,9 @@ impl AsRef 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", } } diff --git a/workspace/tests/self_call_tests.rs b/workspace/tests/self_call_tests.rs new file mode 100644 index 0000000..e936d57 --- /dev/null +++ b/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); +}