feat: add api to get ft balances for multiple accounts

engine-tests/src/tests/erc20_connector.rs

@@ -394,7 +394,6 @@ pub mod workspace {
         nep_141_balance_of, transfer_nep_141, transfer_nep_141_to_erc_20,
     };
     use aurora_engine::parameters::{CallArgs, FunctionCallArgsV2};
-    #[cfg(feature = "ext-connector")]
     use aurora_engine::proof::Proof;
     use aurora_engine_types::parameters::engine::TransactionStatus;
     use aurora_engine_workspace::account::Account;
@@ -408,6 +407,9 @@ pub mod workspace {
     const FT_ACCOUNT: &str = "test_token";
     const INITIAL_ETH_BALANCE: u64 = 777_777_777;
     const ETH_EXIT_AMOUNT: u64 = 111_111_111;
+    const ETH_CUSTODIAN_ADDRESS: &str = "096de9c2b8a5b8c22cee3289b101f6960d68e51e";
+    #[cfg(not(feature = "ext-connector"))]
+    const ONE_YOCTO: NearToken = NearToken::from_yoctonear(1);
 
     #[tokio::test]
     async fn test_ghsa_5c82_x4m4_hcj6_exploit() {
@@ -770,6 +772,49 @@ pub mod workspace {
         );
     }
 
+    #[cfg(not(feature = "ext-connector"))]
+    #[tokio::test]
+    async fn test_ft_balances_of() {
+        use aurora_engine::parameters::FungibleTokenMetadata;
+        use aurora_engine_types::account_id::AccountId;
+        use aurora_engine_types::HashMap;
+
+        let aurora = deploy_engine().await;
+        let metadata = FungibleTokenMetadata::default();
+        aurora
+            .set_eth_connector_contract_data(
+                aurora.id(),
+                ETH_CUSTODIAN_ADDRESS.to_string(),
+                metadata,
+            )
+            .transact()
+            .await
+            .unwrap();
+
+        deposit_balance(&aurora).await;
+
+        let balances: HashMap<AccountId, u128> = HashMap::from([
+            (AccountId::new("account1").unwrap(), 10),
+            (AccountId::new("account2").unwrap(), 20),
+            (AccountId::new("account3").unwrap(), 30),
+        ]);
+
+        for (account_id, amount) in &balances {
+            aurora
+                .ft_transfer(account_id, (*amount).into(), None)
+                .deposit(ONE_YOCTO)
+                .transact()
+                .await
+                .unwrap();
+            let blanace = aurora.ft_balance_of(account_id).await.unwrap().result;
+            assert_eq!(blanace.0, *amount);
+        }
+
+        let accounts = balances.keys().cloned().collect();
+        let result = aurora.ft_balances_of(&accounts).await.unwrap().result;
+        assert_eq!(result, balances);
+    }
+
     async fn test_exit_to_near_eth_common() -> anyhow::Result<TestExitToNearEthContext> {
         let aurora = deploy_engine().await;
         let chain_id = aurora.get_chain_id().await?.result.as_u64();
@@ -975,12 +1020,11 @@ pub mod workspace {
         }
     }
 
-    #[cfg(feature = "ext-connector")]
     async fn deposit_balance(aurora: &EngineContract) {
         let proof = create_test_proof(
             INITIAL_ETH_BALANCE,
             aurora.id().as_ref(),
-            "096de9c2b8a5b8c22cee3289b101f6960d68e51e",
+            ETH_CUSTODIAN_ADDRESS,
         );
         let result = aurora.deposit(proof).max_gas().transact().await.unwrap();
         assert!(result.is_success());
@@ -1004,7 +1048,6 @@ pub mod workspace {
         aurora: EngineContract,
     }
 
-    #[cfg(feature = "ext-connector")]
     fn create_test_proof(
         deposit_amount: u64,
         recipient_id: &str,

engine-workspace/src/contract.rs

@@ -13,7 +13,7 @@ use crate::operation::{
     CallStageUpgrade, CallStateMigration, CallStorageDeposit, CallStorageUnregister,
     CallStorageWithdraw, CallSubmit, CallUpgrade, CallWithdraw, ViewAccountsCounter, ViewBalance,
     ViewBlockHash, ViewBridgeProver, ViewChainId, ViewCode, ViewErc20FromNep141,
-    ViewFactoryWnearAddress, ViewFtBalanceOf, ViewFtBalanceOfEth, ViewFtMetadata,
+    ViewFactoryWnearAddress, ViewFtBalanceOf, ViewFtBalanceOfEth, ViewFtBalancesOf, ViewFtMetadata,
     ViewFtTotalEthSupplyOnAurora, ViewFtTotalEthSupplyOnNear, ViewFtTotalSupply,
     ViewGetErc20Metadata, ViewGetEthConnectorContractAccount, ViewGetFixedGas, ViewGetSiloParams,
     ViewGetWhitelistStatus, ViewIsUsedProof, ViewNep141FromErc20, ViewNonce, ViewOwner,
@@ -377,6 +377,10 @@ impl EngineContract {
         ViewFtBalanceOf::view(&self.contract).args_json(json!({ "account_id": account_id }))
     }
 
+    pub fn ft_balances_of(&self, accounts: &Vec<AccountId>) -> ViewFtBalancesOf {
+        ViewFtBalancesOf::view(&self.contract).args_borsh(accounts)
+    }
+
     pub fn storage_balance_of(&self, account_id: &AccountId) -> ViewStorageBalanceOf {
         ViewStorageBalanceOf::view(&self.contract).args_json(json!({ "account_id": account_id }))
     }

engine-workspace/src/operation.rs

@@ -5,7 +5,7 @@ use aurora_engine_types::parameters::connector::{
 use aurora_engine_types::parameters::engine::{StorageBalance, SubmitResult, TransactionStatus};
 use aurora_engine_types::parameters::silo::{FixedGasArgs, SiloParamsArgs, WhitelistStatusArgs};
 use aurora_engine_types::types::Address;
-use aurora_engine_types::{H256, U256};
+use aurora_engine_types::{HashMap, H256, U256};
 use near_sdk::json_types::U128;
 use near_sdk::PromiseOrValue;
 
@@ -77,6 +77,7 @@ impl_call_return![
 impl_view_return![
     (ViewFtTotalSupply => U128, View::FtTotalSupply, json),
     (ViewFtBalanceOf => U128, View::FtBalanceOf, json),
+    (ViewFtBalancesOf => HashMap<AccountId, u128>, View::FtBalancesOf, borsh),
     (ViewStorageBalanceOf => StorageBalance, View::StorageBalanceOf, json),
     (ViewFtMetadata => FungibleTokenMetadata, View::FtMetadata, json),
     (ViewVersion => String, View::Version, borsh),
@@ -226,6 +227,7 @@ pub enum View {
     IsUsedProof,
     FtTotalSupply,
     FtBalanceOf,
+    FtBalancesOf,
     FtBalanceOfEth,
     FtTotalEthSupplyOnAurora,
     FtTotalEthSupplyOnNear,
@@ -261,6 +263,7 @@ impl AsRef<str> for View {
             View::IsUsedProof => "is_used_proof",
             View::FtTotalSupply => "ft_total_supply",
             View::FtBalanceOf => "ft_balance_of",
+            View::FtBalancesOf => "ft_balances_of",
             View::FtBalanceOfEth => "ft_balance_of_eth",
             View::FtTotalEthSupplyOnAurora => "ft_total_eth_supply_on_aurora",
             View::FtTotalEthSupplyOnNear => "ft_total_eth_supply_on_near",

engine/src/contract_methods/connector/internal.rs

@@ -379,6 +379,13 @@ pub fn ft_balance_of<I: IO + Copy>(io: I) -> Result<(), ContractError> {
     Ok(())
 }
 
+#[cfg(not(feature = "ext-connector"))]
+pub fn ft_balances_of<I: IO + Copy>(io: I) -> Result<(), ContractError> {
+    let accounts: Vec<AccountId> = io.read_input_borsh()?;
+    EthConnectorContract::init(io)?.ft_balances_of(accounts);
+    Ok(())
+}
+
 #[named]
 pub fn finish_deposit<I: IO + Copy, E: Env, H: PromiseHandler>(
     io: I,
@@ -822,6 +829,16 @@ impl<I: IO + Copy> EthConnectorContract<I> {
         self.io.return_output(format!("\"{balance}\"").as_bytes());
     }
 
+    /// Return `nETH` balances for accounts (ETH on NEAR).
+    pub fn ft_balances_of(&mut self, accounts: Vec<AccountId>) {
+        let mut balances = aurora_engine_types::HashMap::new();
+        for account_id in accounts {
+            let balance = self.ft.ft_balance_of(&account_id);
+            balances.insert(account_id, balance);
+        }
+        self.io.return_output(&balances.try_to_vec().unwrap());
+    }
+
     /// Return `ETH` balance (ETH on Aurora).
     pub fn ft_balance_of_eth_on_aurora(
         &mut self,

engine/src/contract_methods/connector/mod.rs

@@ -349,6 +349,12 @@ pub fn ft_balance_of<I: IO + Copy + PromiseHandler>(io: I) -> Result<(), Contrac
     Ok(())
 }
 
+#[cfg(not(feature = "ext-connector"))]
+pub fn ft_balances_of<I: IO + Copy + PromiseHandler>(io: I) -> Result<(), ContractError> {
+    internal::ft_balances_of(io)?;
+    Ok(())
+}
+
 pub fn ft_balance_of_eth<I: IO + Copy>(io: I) -> Result<(), ContractError> {
     let args = io.read_input_borsh()?;
     EthConnectorContract::init(io)?.ft_balance_of_eth_on_aurora(&args)?;

engine/src/lib.rs

@@ -649,6 +649,15 @@ mod contract {
             .sdk_unwrap();
     }
 
+    #[no_mangle]
+    #[cfg(not(feature = "ext-connector"))]
+    pub extern "C" fn ft_balances_of() {
+        let io = Runtime;
+        contract_methods::connector::ft_balances_of(io)
+            .map_err(ContractError::msg)
+            .sdk_unwrap();
+    }
+
     #[no_mangle]
     pub extern "C" fn ft_balance_of_eth() {
         let io = Runtime;