feat: add ri quote calculation

package.json

@@ -26,7 +26,8 @@
     "ts:check": "echo 'No TS type check step'"
   },
   "dependencies": {
-    "@nexusmutual/deployments": "^3.0.0",
+    "@nexusmutual/deployments": "^3.1.0",
+    "@nexusmutual/ethers-v5-aws-kms-signer": "^0.0.1",
     "@nexusmutual/utils": "^0.0.1",
     "convict": "^6.2.4",
     "dotenv": "^16.0.3",

src/config.js

@@ -33,6 +33,26 @@ const config = convict({
     format: Object,
     default: {},
   },
+  awsAccessKeyId: {
+    doc: 'The AWS credentials key ID',
+    default: '',
+    env: 'AWS_ACCESS_KEY_ID',
+  },
+  awsSecretAccessKey: {
+    doc: 'The AWS credentials secret access key',
+    default: '',
+    env: 'AWS_SECRET_ACCESS_KEY',
+  },
+  awsKmsKeyId: {
+    doc: 'The UUID of the AWS KMS key or AWS KMS key alias',
+    default: '',
+    env: 'AWS_KMS_KEY_ID',
+  },
+  awsRegion: {
+    doc: 'The AWS region where the KMS key is located',
+    default: '',
+    env: 'AWS_REGION',
+  },
 });
 
 // Automatically detect and add PRIORITY_POOLS_ORDER environment variables

src/index.js

@@ -10,6 +10,7 @@ const config = require('./config');
 const createChainApi = require('./lib/chainApi');
 const contractFactory = require('./lib/contracts');
 const createEventsApi = require('./lib/eventsApi');
+const riContractFactory = require('./lib/riContracts');
 const swaggerSpec = require('./lib/swagger');
 const createSynchronizer = require('./lib/synchronizer');
 const { capacityRouter, pricingRouter, quoteRouter, reindexRouter } = require('./routes');
@@ -26,11 +27,12 @@ const main = async () => {
   provider.pollingInterval = config.get('pollingInterval');
 
   // contract factory
-  const contracts = await contractFactory(addresses, provider);
+  const contracts = contractFactory(addresses, provider);
+  const riContracts = riContractFactory(provider);
 
   // apis
-  const chainApi = await createChainApi(contracts);
-  const eventsApi = await createEventsApi(provider, contracts);
+  const chainApi = await createChainApi(contracts, riContracts);
+  const eventsApi = await createEventsApi(provider, contracts, riContracts);
 
   const app = express();
 
@@ -72,6 +74,7 @@ const main = async () => {
   if (!isFromCache) {
     console.warn('Missing initial state, delaying startup until the state is fully loaded');
     await synchronizer.updateAssetRates();
+    await synchronizer.updateRiData();
     await synchronizer.updateAll();
   }
 
@@ -83,6 +86,7 @@ const main = async () => {
 
   if (isFromCache) {
     await synchronizer.updateAssetRates();
+    await synchronizer.updateRiData();
     await synchronizer.updateAll();
   }
 };

src/lib/capacityEngine.js

@@ -1,6 +1,6 @@
 const { ethers, BigNumber } = require('ethers');
 
-const { MAX_COVER_PERIOD } = require('./constants');
+const { MAX_COVER_PERIOD, RI_EPOCH_DURATION } = require('./constants');
 const {
   bnMax,
   calculateTrancheId,
@@ -9,7 +9,14 @@ const {
   getCapacitiesInAssets,
   getLatestCover,
 } = require('./helpers');
-const { selectProduct, selectProductPools, selectProductsInPool } = require('../store/selectors');
+const {
+  selectProduct,
+  selectProductPools,
+  selectProductsInPool,
+  selectVaultProducts,
+  selectRiAssetRate,
+  selectVaultEpochExpiryTimestamp,
+} = require('../store/selectors');
 
 const { WeiPerEther, Zero } = ethers.constants;
 
@@ -60,7 +67,7 @@ function calculatePoolUtilizationRate(products) {
 function calculateProductCapacity(
   store,
   productId,
-  { poolId = null, period, now, assets, assetRates, withPools = true, editedCover = null },
+  { poolId = null, vaultId = null, period, now, assets, assetRates, withPools = true, editedCover = null },
 ) {
   const product = selectProduct(store, productId);
   if (!product) {
@@ -120,10 +127,42 @@ function calculateProductCapacity(
     }
   }
 
+  let totalRiCapacity = Zero;
+  if (!poolId) {
+    const expiries = selectVaultEpochExpiryTimestamp(store);
+    const coverExpiry = now.add(product.gracePeriod).add(period);
+    const epochDuration = RI_EPOCH_DURATION * 24 * 3600;
+    const riVaults = selectVaultProducts(store, productId);
+
+    totalRiCapacity = riVaults
+      .filter(vault => vault && expiries[vault.vaultId] && expiries[vault.vaultId].add(epochDuration).gt(coverExpiry))
+      .reduce((total, vault) => {
+        const assetRate = selectRiAssetRate(store, vault.asset);
+        if (!assetRate) {
+          return total; // Skip vaults without asset rate
+        }
+        const allocatedAmount = (vault.allocations || []).reduce((acc, allocation) => {
+          // cover edit allocation
+          if (allocation.expiryTimestamp > now && allocation.coverId !== editedCover?.coverId && allocation.active) {
+            acc = acc.add(allocation.amount);
+          }
+          return acc;
+        }, BigNumber.from(0));
+        // All values are in vault asset units: activeStake, withdrawalAmount, and allocatedAmount
+        // Convert to NXM at the end
+        const availableCapacityInAsset = vault.activeStake.add(vault.withdrawalAmount).sub(allocatedAmount);
+        const availableCapacityInNXM = availableCapacityInAsset.mul(assetRate).div(WeiPerEther);
+        return total.add(availableCapacityInNXM);
+      }, Zero);
+  }
+
   const { capacityAvailableNXM, capacityUsedNXM, minPrice } = aggregatedData;
 
+  // Add RI capacity to pool capacity
+  const totalCapacityAvailableNXM = capacityAvailableNXM.add(totalRiCapacity);
+
   // The available (i.e. remaining) capacity of a product
-  const capacityInAssets = getCapacitiesInAssets(capacityAvailableNXM, assets, assetRates);
+  const capacityInAssets = getCapacitiesInAssets(totalCapacityAvailableNXM, assets, assetRates);
 
   const capacityData = {
     productId: Number(productId),

src/lib/chainApi.js

@@ -1,7 +1,11 @@
-const { ethers } = require('ethers');
+const { BigNumber, ethers } = require('ethers');
+
+const constants = require('./constants');
+
 const { WeiPerEther } = ethers.constants;
+const { defaultAbiCoder } = ethers.utils;
 
-const createChainApi = async contracts => {
+const createChainApi = async (contracts, riContracts) => {
   // contract instances
   const cover = contracts('Cover');
   const coverProducts = contracts('CoverProducts');
@@ -108,6 +112,83 @@ const createChainApi = async contracts => {
     return packedTrancheAllocation;
   };
 
+  // RiContracts
+  const fetchVaultStake = async (vaultId, subnetworks = [], productId = null, riSubnetworks = {}) => {
+    const operator = '0x51ad1265C8702c9e96Ea61Fe4088C2e22eD4418e';
+    let maxWeightedStake = BigNumber.from(0);
+
+    for (const subnetworkId of subnetworks) {
+      const subnetworkStake = await riContracts[`delegator_${vaultId}`].stake(subnetworkId, operator);
+
+      // Determine the weight to use for this subnetwork
+      let weight = constants.RI_WEIGHT; // Default weight
+
+      if (productId !== null && riSubnetworks && riSubnetworks[subnetworkId]) {
+        const subnetwork = riSubnetworks[subnetworkId];
+        // Check if this subnetwork contains the product
+        if (subnetwork.products && subnetwork.products[String(productId)]) {
+          weight = subnetwork.products[String(productId)].weight;
+        }
+      }
+
+      // Calculate weighted stake for this subnetwork: stake * weight / 100
+      const weightedStake = subnetworkStake.mul(weight).div(constants.RI_WEIGHT_DENOMINATOR);
+
+      // Keep track of the maximum weighted stake across all subnetworks
+      // This allows a subnetwork with lower stake but higher weight to win
+      maxWeightedStake = weightedStake.gt(maxWeightedStake) ? weightedStake : maxWeightedStake;
+    }
+
+    return maxWeightedStake;
+  };
+
+  const fetchVaultWithdrawals = async vaultId => {
+    console.log(riContracts[`vault_${vaultId}`].address);
+    const currentEpoch = await riContracts[`vault_${vaultId}`].currentEpoch();
+    const withdrawalAmount = await riContracts[`vault_${vaultId}`].withdrawals(currentEpoch + 1);
+    return withdrawalAmount.mul(constants.RI_WEIGHT).div(constants.RI_WEIGHT_DENOMINATOR);
+  };
+
+  const fetchVaultAllocations = async blockNumber => {
+    const events = await cover.queryFilter(cover.filters.CoverRiAllocated(), blockNumber);
+
+    const allocations = {};
+    for (const event of events) {
+      const { args } = event;
+      const { coverId, data, dataFormat } = args;
+
+      const { start, period, productId, originalCoverId } = await fetchCover(coverId);
+      const coverAllocations = defaultAbiCoder.decode([constants.RI_DATA_FORMATS[dataFormat]], [data]);
+
+      for (const coverAllocation of coverAllocations) {
+        const { amount, vaultId } = coverAllocation;
+        if (!allocations[vaultId]) {
+          allocations[`${productId}_${vaultId}`] = [];
+        }
+
+        allocations[`${productId}_${vaultId}`].push({
+          amount,
+          coverId,
+          expiryTimestamp: start + period,
+          originalCoverId,
+        });
+      }
+    }
+
+    return allocations;
+  };
+
+  const fetchVaultNextEpochStart = async vaultId => {
+    return await riContracts[`vault_${vaultId}`].nextEpochStart();
+  };
+
+  const fetchRiAssetRate = async assetId => {
+    return {
+      assetRate: await riContracts[`asset_${assetId}`].getRate(),
+      protocolAssetCorrelationId: riContracts[`asset_${assetId}`].protocolAssetCorrelationId,
+    };
+  };
+
   return {
     fetchProducts,
     fetchProduct,
@@ -122,6 +203,11 @@ const createChainApi = async contracts => {
     fetchCover,
     fetchCoverPoolTrancheAllocations,
     fetchCoverReference,
+    fetchVaultStake,
+    fetchVaultWithdrawals,
+    fetchVaultAllocations,
+    fetchVaultNextEpochStart,
+    fetchRiAssetRate,
   };
 };
 

src/lib/constants.js

@@ -46,7 +46,21 @@ module.exports = {
   SECONDS_PER_DAY: BigNumber.from(24 * 60 * 60),
 
   // set to minimal cover id which is not expired
-  FETCH_COVER_DATA_FROM_ID: 992,
+  FETCH_COVER_DATA_FROM_ID: 3710,
 
+  // Ri constants
+  SYMBIOTIC_PROVIDER_ID: 1,
+  RI_FETCH_COVER_DATA_FROM_BLOCK: 24219565,
+  RI_WEIGHT: 25,
+  RI_WEIGHT_DENOMINATOR: 100,
+  RI_THRESHOLD: 20_000_000 * 1_000_000, // in USDC
+  RI_MIN_COVER_AMOUNT: 100_000 * 1_000_000, // in USDC
+  RI_COVER_AMOUNT_PERCENTAGE: 80,
+  RI_COVER_AMOUNT_DENOMINATOR: 100,
+  RI_EPOCH_DURATION: 70, // days
+
+  RI_DATA_FORMATS: {
+    1: 'tuple(uint256 amount,uint256 vaultId, uint256 subnetworkId,uint256 providerId)[]',
+  },
   HTTP_STATUS,
 };

src/lib/eventsApi.js

@@ -6,7 +6,7 @@ const { calculateTrancheId, calculateBucketId } = require('./helpers');
 
 const events = ['StakeBurned', 'DepositExtended', 'StakeDeposited', 'PoolFeeChanged', 'Deallocated'];
 
-module.exports = async (provider, contracts) => {
+module.exports = async (provider, contracts, riContracts) => {
   // event emitter
   const emitter = new EventEmitter();
 
@@ -24,12 +24,12 @@ module.exports = async (provider, contracts) => {
 
   // emit an event on every block
   provider.on('block', async blockNumber => {
+    const { timestamp: blockTimestamp } = await provider.getBlock(blockNumber);
     const now = Math.floor(Date.now() / 1000);
     const activeBucketId = calculateBucketId(now);
     const activeTrancheId = calculateTrancheId(now);
 
     if (activeBucketId !== currentBucketId) {
-      const { timestamp: blockTimestamp } = await provider.getBlock(blockNumber);
       const blockBucketId = calculateBucketId(blockTimestamp);
 
       if (blockBucketId === activeBucketId) {
@@ -41,7 +41,6 @@ module.exports = async (provider, contracts) => {
     }
 
     if (activeTrancheId !== currentTrancheId) {
-      const { timestamp: blockTimestamp } = await provider.getBlock(blockNumber);
       const blockTrancheId = calculateTrancheId(blockTimestamp);
 
       if (blockTrancheId === activeTrancheId) {
@@ -52,7 +51,7 @@ module.exports = async (provider, contracts) => {
       }
     }
 
-    emitter.emit('block', blockNumber);
+    emitter.emit('block', blockNumber, blockTimestamp);
   });
 
   // listeners
@@ -104,6 +103,40 @@ module.exports = async (provider, contracts) => {
     emitter.emit('cover:change', coverId);
   });
 
+  // Cover Ri events
+  cover.on('CoverRiAllocated', (coverId, premium, paymentAsset, data, dataFormat) => {
+    console.info(`Event: Cover ${coverId} allocated with RI`);
+    emitter.emit('ri:bought', coverId, data, dataFormat);
+  });
+
+  for (const contractName of Object.keys(riContracts)) {
+    const vaultId = contractName.split('_')[1];
+    if (contractName.startsWith('vault_')) {
+      riContracts[contractName].on('Withdraw', () => {
+        console.info(`Event: Withdraw for vault ${vaultId}`);
+        emitter.emit('ri:withdraw', vaultId);
+      });
+      riContracts[`vault_${vaultId}`].on('Deposit', () => {
+        console.info(`Event: Deposit for vault ${vaultId}`);
+        emitter.emit('ri:deposit', vaultId);
+      });
+      riContracts[`vault_${vaultId}`].on('OnSlash', () => {
+        console.info(`Event: Slash for vault ${vaultId}`);
+        emitter.emit('ri:slash', vaultId);
+      });
+    }
+    if (contractName.startsWith('delegator_')) {
+      riContracts[`delegator_${vaultId}`].on('SetMaxNetworkLimit', () => {
+        console.info(`Event: SetMaxNetworkLimit for vault ${vaultId}`);
+        emitter.emit('ri:setMaxNetworkLimit', vaultId);
+      });
+      riContracts[`delegator_${vaultId}`].on('SetNetworkLimit', () => {
+        console.info(`Event: SetNetworkLimit for vault ${vaultId}`);
+        emitter.emit('ri:setNetworkLimit', vaultId);
+      });
+    }
+  }
+
   return {
     on: emitter.on.bind(emitter),
     off: emitter.off.bind(emitter),

src/lib/helpers.js

@@ -13,12 +13,14 @@ const {
   CAPACITY_BUFFER_MINIMUM,
   MAX_ACTIVE_TRANCHES,
   HTTP_STATUS,
+  RI_DATA_FORMATS,
 } = require('./constants');
 const { ApiError } = require('./error');
 const { selectCover } = require('../store/selectors');
 
 const { BigNumber } = ethers;
 const { WeiPerEther, Zero } = ethers.constants;
+const { defaultAbiCoder } = ethers.utils;
 
 /* Bignumber Utils */
 
@@ -301,6 +303,10 @@ function getLatestCover(store, originalCoverId) {
     : selectCover(store, originalCover.latestCoverId);
 }
 
+const decodeRiData = (data, dataFormat) => {
+  return defaultAbiCoder.decode([RI_DATA_FORMATS[dataFormat]], [data]);
+};
+
 module.exports = {
   bnMax,
   bnMin,
@@ -319,4 +325,5 @@ module.exports = {
   getCoverTrancheAllocations,
   calculateCoverRefundInNXM,
   getLatestCover,
+  decodeRiData,
 };