ReserveConstraint

scenario/WithdrawReservesScenario.ts

@@ -6,6 +6,7 @@ import { expect } from 'chai';
 scenario(
   'Comet#withdrawReserves > governor withdraw reserves',
   {
+    reserves: '>= 150000',
     tokenBalances: {
       betty: { $base: '== 100000' },
       albert: { $base: '== 0' },

scenario/constraints/Requirements.ts

@@ -8,4 +8,5 @@ export interface Requirements {
     tokenBalances?: object; // Token balance constraint
     utilization?: number; // Utilization constraint
     prices?: object; // Price constraint
+    reserves?: number | string // Reserves constraint
 }

scenario/constraints/ReservesConstraint.ts

@@ -0,0 +1,66 @@
+import { Constraint, Solution } from '../../plugins/scenario';
+import { CometContext } from '../context/CometContext';
+import CometActor from '../context/CometActor';
+import { expect } from 'chai';
+import { Requirements } from './Requirements';
+import { baseBalanceOf, exp, factorScale } from '../../test/helpers';
+import { ComparativeAmount, ComparisonOp, getAssetFromName, parseAmount, getExpectedBaseBalance, getToTransferAmount } from '../utils';
+import { BigNumber } from 'ethers';
+
+export class ReservesConstraint<T extends CometContext, R extends Requirements> implements Constraint<T, R> {
+  async solve(requirements: R, initialContext: T) {
+    const reservesRequirement = requirements.reserves;
+    if (reservesRequirement !== undefined) {
+
+      const comet = await initialContext.getComet();
+
+      const solutions: Solution<T>[] = [];
+      solutions.push(async function barelyMeet(context: T) {
+        const baseToken = await comet.baseToken();
+        const currentReserves = (await comet.getReserves()).toBigInt();
+        const amount = parseAmount(reservesRequirement);
+        const decimals = await comet.decimals();
+
+        expect(amount.op).to.equal(ComparisonOp.GTE, `Operation ${amount.op} not supported (yet) by reserve cap constraint`);
+
+        const amountToSource = getToTransferAmount(amount, currentReserves, decimals);
+        // add buffer to adjust for interest accrual
+        await context.sourceTokens(amountToSource * 105n / 100n, baseToken, comet.address);
+
+        return context;
+      });
+      return solutions;
+    } else {
+      return null;
+    }
+  }
+
+  async check(requirements: R, context: T) {
+    const reservesRequirement = requirements.reserves;
+    if (reservesRequirement !== undefined) {
+      const comet = await context.getComet();
+      const amount = parseAmount(reservesRequirement);
+      const decimals = await comet.decimals();
+      const currentReserves = (await comet.getReserves()).toBigInt();
+      const expectedReserves = exp(amount.val, decimals);
+
+      switch (amount.op) {
+        case ComparisonOp.EQ:
+          expect(currentReserves).to.equal(expectedReserves);
+          break;
+        case ComparisonOp.GTE:
+          expect(currentReserves).to.be.at.least(expectedReserves);
+          break;
+        case ComparisonOp.LTE:
+          expect(currentReserves).to.be.at.most(expectedReserves);
+          break;
+        case ComparisonOp.GT:
+          expect(currentReserves).to.be.above(expectedReserves);
+          break;
+        case ComparisonOp.LT:
+          expect(currentReserves).to.be.below(expectedReserves);
+          break;
+      }
+    }
+  }
+}

scenario/constraints/index.ts

@@ -9,3 +9,4 @@ export { MigrationConstraint } from './MigrationConstraint';
 export { ProposalConstraint } from './ProposalConstraint';
 export { FilterConstraint } from './FilterConstraint';
 export { PriceConstraint } from './PriceConstraint';
+export { ReservesConstraint } from './ReservesConstraint';

scenario/context/CometContext.ts

@@ -12,7 +12,8 @@ import {
   MigrationConstraint,
   ProposalConstraint,
   FilterConstraint,
-  PriceConstraint
+  PriceConstraint,
+  ReservesConstraint
 } from '../constraints';
 import CometActor from './CometActor';
 import CometAsset from './CometAsset';
@@ -414,7 +415,8 @@ export const dynamicConstraints: DynamicConstraint<CometContext, Requirements>[]
   new CometBalanceConstraint(),
   new TokenBalanceConstraint(),
   new UtilizationConstraint(),
-  new PriceConstraint()
+  new PriceConstraint(),
+  new ReservesConstraint()
 ];
 
 export const scenarioLoader = Loader.get<CometContext, CometProperties, Requirements>().configure(