refactor: use queryMulti for staking computation

src/parachain/rewards.ts

@@ -14,6 +14,7 @@ import {
 import { AssetRegistryAPI, InterbtcPrimitivesVaultId, LoansAPI } from "../parachain";
 import { TransactionAPI } from "../parachain/transaction";
 import { WrappedCurrency, CollateralCurrencyExt, CurrencyExt } from "../types";
+import { SignedFixedPoint } from "..";
 
 export interface RewardsAPI {
     /**
@@ -161,11 +162,40 @@ export class DefaultRewardsAPI implements RewardsAPI {
             this.loansAPI,
             vaultId.currencies.collateral
         );
-        const [stake, slashPerToken, slashTally] = await Promise.all([
-            this.getStakingPoolStake(collateralCurrency, vaultId.accountId, nominatorId),
-            this.getStakingPoolSlashPerToken(collateralCurrency, vaultId.accountId),
-            this.getStakingPoolSlashTally(collateralCurrency, vaultId.accountId, nominatorId),
-        ]);
+        const nonce = await this.getStakingPoolNonce(collateralCurrency, vaultId.accountId);
+        const [stake, slashPerToken, slashTally] = await this.api.queryMulti<[
+            SignedFixedPoint,
+            SignedFixedPoint,
+            SignedFixedPoint,
+        ]>([
+            [
+                this.api.query.vaultStaking.stake,
+                [
+                    nonce,
+                    [
+                        vaultId,
+                        nominatorId
+                    ]
+                ]
+            ],
+            [
+                this.api.query.vaultStaking.slashPerToken,
+                [
+                    nonce,
+                    vaultId
+                ]
+            ],
+            [
+                this.api.query.vaultStaking.slashTally,
+                [
+                    nonce,
+                    [
+                        vaultId,
+                        nominatorId
+                    ]
+                ]
+            ],
+        ]).then((data) => data.map((value) => decodeFixedPointType(value)));
         const toSlash = computeLazyDistribution(stake, slashPerToken, slashTally);
         return newMonetaryAmount(
             stake.sub(toSlash),

src/parachain/vaults.ts

@@ -35,7 +35,6 @@ import {
     CollateralCurrencyExt,
     WrappedCurrency,
     GovernanceCurrency,
-    CurrencyExt,
 } from "../types";
 import { RewardsAPI } from "./rewards";
 import { UnsignedFixedPoint } from "../interfaces";
@@ -628,15 +627,6 @@ export class DefaultVaultsAPI implements VaultsAPI {
         return annualRewardRate.mul(100);
     }
 
-    async getLockedCollateral(
-        vaultAccountId: AccountId,
-        collateralCurrency: CollateralCurrencyExt
-    ): Promise<MonetaryAmount<CurrencyExt>> {
-        // TODO: This might be inaccurate if the "reserved" value is incremented by other protocols
-        // See comment: https://github.com/interlay/interbtc-api/pull/464#discussion_r954909315
-        return (await this.tokensAPI.balance(collateralCurrency, vaultAccountId)).reserved;
-    }
-
     async computeReward(
         vaultAccountId: AccountId,
         collateralCurrency: CollateralCurrencyExt,
@@ -970,7 +960,7 @@ export class DefaultVaultsAPI implements VaultsAPI {
     async getAPY(vaultAccountId: AccountId, collateralCurrency: CollateralCurrencyExt): Promise<Big> {
         const [feesWrapped, lockedCollateral, blockRewardsAPY] = await Promise.all([
             this.getWrappedReward(vaultAccountId, collateralCurrency),
-            this.getLockedCollateral(vaultAccountId, collateralCurrency),
+            this.getCollateral(vaultAccountId, collateralCurrency),
             this.getBlockRewardAPY(vaultAccountId, collateralCurrency),
         ]);
         return (await this.feeAPI.calculateAPY(feesWrapped, lockedCollateral)).add(blockRewardsAPY);
@@ -1060,7 +1050,7 @@ export class DefaultVaultsAPI implements VaultsAPI {
         const [vaultExt, liquidationRateThreshold, lockedCollateral] = await Promise.all([
             this.get(vaultAccountId, collateralCurrency),
             this.getLiquidationCollateralThreshold(collateralCurrency),
-            this.getLockedCollateral(vaultAccountId, collateralCurrency),
+            this.getCollateral(vaultAccountId, collateralCurrency),
         ]);
 
         if (liquidationRateThreshold.eq(0)) {

test/integration/parachain/staging/setup/initialize.test.ts

@@ -420,6 +420,12 @@ describe("Initialize parachain state", () => {
             const vaultInterBtcApi = new DefaultInterBtcApi(api, "regtest", vaultKeyringPair, ESPLORA_BASE_PATH);
             const collateralAmount = new MonetaryAmount(aUsd, 10000);
             await vaultInterBtcApi.vaults.registerNewCollateralVault(collateralAmount);
+            // sanity check the collateral computation
+            const actualCollateralAmount = await vaultInterBtcApi.vaults.getCollateral(vaultAccountId, aUsd);
+            assert.equal(
+                actualCollateralAmount.toString(),
+                collateralAmount.toString(),
+            );
         }
     });
 

test/unit/mocks/vaultsTestMocks.ts

@@ -186,7 +186,7 @@ export const prepareLiquidationRateMocks = (
     // if we have less than 2x collateral (in BTC) compared to BTC, we need to liquidate
     sinon.stub(vaultsApi, "getLiquidationCollateralThreshold").returns(Promise.resolve(Big(mockLiquidationThreshold)));
 
-    // mock this.getLockedCollateral return value
-    const mockLockedCollateral = new MonetaryAmount(collateralCurrency, mockCollateralTokensNumber);
-    sinon.stub(vaultsApi, "getLockedCollateral").returns(Promise.resolve(mockLockedCollateral));
+    // mock this.getCollateral return value
+    const mockCollateral = new MonetaryAmount(collateralCurrency, mockCollateralTokensNumber);
+    sinon.stub(vaultsApi, "getCollateral").returns(Promise.resolve(mockCollateral));
 };