Fix more typescript type inconsistencies (compound-finance#711)

This fixes some more type inconsistencies that Typescript was complaining about throughout the scenario codebase.
api3dao · Mar 9, 2023 · c2155cb · c2155cb
1 parent 91c91b6
commit c2155cb
Show file tree

Hide file tree

Showing 24 changed files with 106 additions and 82 deletions.
diff --git a/plugins/deployment_manager/test/CacheTest.ts b/plugins/deployment_manager/test/CacheTest.ts
@@ -1,6 +1,5 @@
 import { expect } from 'chai';
 import { tempDir } from './TestHelpers';
-
 import { Cache } from '../Cache';
 import { objectFromMap } from '../Utils';
 
@@ -61,11 +60,11 @@ describe('Cache', () => {
 
       expect(cache.cache).to.eql(new Map([['test-network', new Map([['test-deployment', new Map([['abc', new Map([['a', 5]])]])]])]]));
 
-      expect(objectFromMap(await cache.readCache({ rel: 'abc' }))).to.eql({a: 5});
+      expect(objectFromMap(await cache.readCache<Map<string, number>>({ rel: 'abc' }))).to.eql({a: 5});
 
       await cache.storeMap({ rel: 'abc' }, new Map([['a', 6]]));
 
-      expect(objectFromMap(await cache.readCache({ rel: 'abc' }))).to.eql({a: 6});
+      expect(objectFromMap(await cache.readCache<Map<string, number>>({ rel: 'abc' }))).to.eql({a: 6});
     });
   });
 

diff --git a/plugins/deployment_manager/test/MigrationTest.ts b/plugins/deployment_manager/test/MigrationTest.ts
@@ -7,29 +7,29 @@ describe('Migration', () => {
   it('test a simple migration', async () => {
     let x = [];
     let m = migration('test migration', {
-      prepare: async (_deploymentManager) => {
+      prepare: async (_deploymentManager, _govDm) => {
         x = [...x, 'step 1'];
         return 'step 2';
       },
-      enact: async (_deploymentManager, y) => {
+      enact: async (_deploymentManager, _govDm, y) => {
         x = [...x, y];
       }
     });
     let dm = new DeploymentManager('test-network', 'test-deployment', hre);
     expect(m.name).to.eql('test migration');
     expect(x).to.eql([]);
-    let v = await m.actions.prepare(dm);
+    let v = await m.actions.prepare(dm, dm);
     expect(x).to.eql(['step 1']);
-    await m.actions.enact(dm, v);
+    await m.actions.enact(dm, dm, v);
     expect(x).to.eql(['step 1', 'step 2']);
   });
 
   it('loads a simple migration', async () => {
     let [m] = await loadMigrations([`${__dirname}/migration.ts`]);
     let dm = new DeploymentManager('test-network', 'test-market', hre);
     expect(m.name).to.eql('test migration');
-    expect(await m.actions.prepare(dm)).to.eql(['step 1']);
-    expect(await m.actions.enact(dm, [])).to.eql(undefined);
+    expect(await m.actions.prepare(dm, dm)).to.eql(['step 1']);
+    expect(await m.actions.enact(dm, dm, [])).to.eql(undefined);
   });
 
   it('returns proper artifact file spec', async () => {

diff --git a/plugins/scenario/index.ts b/plugins/scenario/index.ts
@@ -1,4 +1,4 @@
-export { Constraint, Initializer, Property, Scenario, Solution, Transformer } from './Scenario';
+export { Constraint, Initializer, Property, Scenario, Solution, StaticConstraint, Transformer } from './Scenario';
 export { Loader } from './Loader';
 export { ForkSpec, World } from './World';
 export { debug } from '../deployment_manager/Utils';
diff --git a/scenario/BulkerScenario.ts b/scenario/BulkerScenario.ts
@@ -75,8 +75,8 @@ scenario(
     expect(await comet.collateralBalanceOf(albert.address, collateralAsset.address)).to.be.equal(toSupplyCollateral);
     expect(await comet.collateralBalanceOf(albert.address, wrappedNativeToken)).to.be.equal(toSupplyEth - toWithdrawEth);
     expect(await baseAsset.balanceOf(albert.address)).to.be.equal(toBorrowBase);
-    expectBase(await comet.balanceOf(betty.address), baseTransferred);
-    expectBase(await comet.borrowBalanceOf(albert.address), toBorrowBase + toTransferBase);
+    expectBase((await comet.balanceOf(betty.address)).toBigInt(), baseTransferred);
+    expectBase((await comet.borrowBalanceOf(albert.address)).toBigInt(), toBorrowBase + toTransferBase);
 
     return txn; // return txn to measure gas
   }
@@ -150,8 +150,8 @@ scenario(
     const baseTransferred = getExpectedBaseBalance(toTransferBase, baseIndexScale, baseSupplyIndex);
     expect(await comet.collateralBalanceOf(albert.address, collateralAsset.address)).to.be.equal(toSupplyCollateral);
     expect(await baseAsset.balanceOf(albert.address)).to.be.equal(toBorrowBase);
-    expectBase(await comet.balanceOf(betty.address), baseTransferred);
-    expectBase(await comet.borrowBalanceOf(albert.address), toBorrowBase + toTransferBase - (toSupplyEth - toWithdrawEth));
+    expectBase((await comet.balanceOf(betty.address)).toBigInt(), baseTransferred);
+    expectBase((await comet.borrowBalanceOf(albert.address)).toBigInt(), toBorrowBase + toTransferBase - (toSupplyEth - toWithdrawEth));
 
     return txn; // return txn to measure gas
   }
@@ -245,8 +245,8 @@ scenario(
     expect(await baseAsset.balanceOf(albert.address)).to.be.equal(toBorrowBase);
     expect(await comet.collateralBalanceOf(albert.address, wrappedNativeToken)).to.be.equal(toSupplyEth - toWithdrawEth);
     expect(await albert.getErc20Balance(rewardTokenAddress)).to.be.equal(expectedFinalRewardBalance);
-    expectBase(await comet.balanceOf(betty.address), baseTransferred);
-    expectBase(await comet.borrowBalanceOf(albert.address), toBorrowBase + toTransferBase);
+    expectBase((await comet.balanceOf(betty.address)).toBigInt(), baseTransferred);
+    expectBase((await comet.borrowBalanceOf(albert.address)).toBigInt(), toBorrowBase + toTransferBase);
 
     return txn; // return txn to measure gas
   }
@@ -338,9 +338,9 @@ scenario(
     expect(await comet.collateralBalanceOf(albert.address, collateralAsset.address)).to.be.equal(toSupplyCollateral);
     expect(await baseAsset.balanceOf(albert.address)).to.be.equal(toBorrowBase);
     expect(await albert.getErc20Balance(rewardTokenAddress)).to.be.equal(expectedFinalRewardBalance);
-    expectBase(await comet.balanceOf(betty.address), baseTransferred);
+    expectBase((await comet.balanceOf(betty.address)).toBigInt(), baseTransferred);
     // NOTE: differs from the equivalent scenario for non-ETH markets
-    expectBase(await comet.borrowBalanceOf(albert.address), toBorrowBase + toTransferBase - (toSupplyEth - toWithdrawEth));
+    expectBase((await comet.borrowBalanceOf(albert.address)).toBigInt(), toBorrowBase + toTransferBase - (toSupplyEth - toWithdrawEth));
 
     return txn; // return txn to measure gas
   }

diff --git a/scenario/MainnetBulkerScenario.ts b/scenario/MainnetBulkerScenario.ts
@@ -4,7 +4,8 @@ import { scenario } from './context/CometContext';
 import CometAsset from './context/CometAsset';
 import {
   ERC20,
-  IWstETH
+  IWstETH,
+  MainnetBulker
 } from '../build/types';
 import { exp } from '../test/helpers';
 import { expectApproximately, isBulkerSupported, matchesDeployment } from './utils';
@@ -40,7 +41,7 @@ scenario(
       [comet.address, albert.address, toSupplyStEth]
     );
     const calldata = [supplyStEthCalldata];
-    const actions = [await bulker.ACTION_SUPPLY_STETH()];
+    const actions = [await (bulker as MainnetBulker).ACTION_SUPPLY_STETH()];
 
     await albert.invoke({ actions, calldata });
 
@@ -71,8 +72,8 @@ scenario(
   async ({ comet, actors, bulker }, context) => {
     const { albert } = actors;
 
-    const stETH = await context.world.deploymentManager.contract('stETH');
-    const wstETH = await context.world.deploymentManager.contract('wstETH');
+    const stETH = await context.world.deploymentManager.getContractOrThrow('stETH');
+    const wstETH = await context.world.deploymentManager.getContractOrThrow('wstETH');
 
     await albert.allow(bulker.address, true);
 
@@ -83,7 +84,7 @@ scenario(
       [comet.address, albert.address, toWithdrawStEth]
     );
     const calldata = [withdrawStEthCalldata];
-    const actions = [await bulker.ACTION_WITHDRAW_STETH()];
+    const actions = [await (bulker as MainnetBulker).ACTION_WITHDRAW_STETH()];
 
     await albert.invoke({ actions, calldata });
 
@@ -130,7 +131,7 @@ scenario(
       [comet.address, albert.address, ethers.constants.MaxUint256]
     );
     const calldata = [withdrawStEthCalldata];
-    const actions = [await bulker.ACTION_WITHDRAW_STETH()];
+    const actions = [await (bulker as MainnetBulker).ACTION_WITHDRAW_STETH()];
 
     await albert.invoke({ actions, calldata });
 

diff --git a/scenario/SupplyScenario.ts b/scenario/SupplyScenario.ts
@@ -5,7 +5,7 @@ import { ContractReceipt } from 'ethers';
 
 // XXX introduce a SupplyCapConstraint to separately test the happy path and revert path instead
 // of testing them conditionally
-async function testSupplyCollateral(context: CometContext, assetNum: number): Promise<null | ContractReceipt> {
+async function testSupplyCollateral(context: CometContext, assetNum: number): Promise<void | ContractReceipt> {
   const comet = await context.getComet();
   const { albert } = await context.actors;
   const { asset: assetAddress, scale: scaleBN, supplyCap } = await comet.getAssetInfo(assetNum);
@@ -36,7 +36,7 @@ async function testSupplyCollateral(context: CometContext, assetNum: number): Pr
   }
 }
 
-async function testSupplyFromCollateral(context: CometContext, assetNum: number): Promise<null | ContractReceipt> {
+async function testSupplyFromCollateral(context: CometContext, assetNum: number): Promise<void | ContractReceipt> {
   const comet = await context.getComet();
   const { albert, betty } = await context.actors;
   const { asset: assetAddress, scale: scaleBN, supplyCap } = await comet.getAssetInfo(assetNum);

diff --git a/scenario/TransferScenario.ts b/scenario/TransferScenario.ts
@@ -3,7 +3,7 @@ import { expect } from 'chai';
 import { expectApproximately, expectBase, expectRevertCustom, getInterest, isTriviallySourceable, isValidAssetIndex, MAX_ASSETS } from './utils';
 import { ContractReceipt } from 'ethers';
 
-async function testTransferCollateral(context: CometContext, assetNum: number): Promise<null | ContractReceipt> {
+async function testTransferCollateral(context: CometContext, assetNum: number): Promise<void | ContractReceipt> {
   const comet = await context.getComet();
   const { albert, betty } = context.actors;
   const { asset: assetAddress, scale } = await comet.getAssetInfo(assetNum);
@@ -19,7 +19,7 @@ async function testTransferCollateral(context: CometContext, assetNum: number):
   return txn; // return txn to measure gas
 }
 
-async function testTransferFromCollateral(context: CometContext, assetNum: number): Promise<null | ContractReceipt> {
+async function testTransferFromCollateral(context: CometContext, assetNum: number): Promise<void | ContractReceipt> {
   const comet = await context.getComet();
   const { albert, betty, charles } = context.actors;
   const { asset: assetAddress, scale } = await comet.getAssetInfo(assetNum);

diff --git a/scenario/WithdrawScenario.ts b/scenario/WithdrawScenario.ts
@@ -3,7 +3,7 @@ import { expect } from 'chai';
 import { expectApproximately, expectRevertCustom, isTriviallySourceable, isValidAssetIndex, MAX_ASSETS } from './utils';
 import { ContractReceipt } from 'ethers';
 
-async function testWithdrawCollateral(context: CometContext, assetNum: number): Promise<null | ContractReceipt> {
+async function testWithdrawCollateral(context: CometContext, assetNum: number): Promise<void | ContractReceipt> {
   const comet = await context.getComet();
   const { albert } = context.actors;
   const { asset: assetAddress, scale: scaleBN } = await comet.getAssetInfo(assetNum);
@@ -22,7 +22,7 @@ async function testWithdrawCollateral(context: CometContext, assetNum: number):
   return txn; // return txn to measure gas
 }
 
-async function testWithdrawFromCollateral(context: CometContext, assetNum: number): Promise<null | ContractReceipt> {
+async function testWithdrawFromCollateral(context: CometContext, assetNum: number): Promise<void | ContractReceipt> {
   const comet = await context.getComet();
   const { albert, betty } = context.actors;
   const { asset: assetAddress, scale: scaleBN } = await comet.getAssetInfo(assetNum);

diff --git a/scenario/constraints/CometBalanceConstraint.ts b/scenario/constraints/CometBalanceConstraint.ts
@@ -1,4 +1,4 @@
-import { Constraint } from '../../plugins/scenario';
+import { Constraint, Solution } from '../../plugins/scenario';
 import { CometContext } from '../context/CometContext';
 import CometActor from '../context/CometActor';
 import { expect } from 'chai';
@@ -56,7 +56,7 @@ export class CometBalanceConstraint<T extends CometContext, R extends Requiremen
 
       // XXX ideally when properties fail
       //  we can report the names of the solution which were applied
-      const solutions = [];
+      const solutions: Solution<T>[] = [];
       solutions.push(async function barelyMeet(context: T) {
         const comet = await context.getComet();
         for (const assetName in actorsByAsset) {
@@ -100,6 +100,8 @@ export class CometBalanceConstraint<T extends CometContext, R extends Requiremen
         return context;
       });
       return solutions;
+    } else {
+      return null;
     }
   }
 

diff --git a/scenario/constraints/Fuzzing.ts b/scenario/constraints/Fuzzing.ts
@@ -81,7 +81,7 @@ export function getFuzzedValues(fuzzConfig: FuzzConfig): any[] {
 }
 
 export function getFuzzedRequirements(requirements: Requirements): Requirements[] {
-  let fuzzedRequirements = [];
+  let fuzzedRequirements: Requirements[] = [];
   let keyValues: KV[][] = [];
   // Create a list of fuzzed values for each key that needs to be fuzzed.
   for (let key in requirements) {

diff --git a/scenario/constraints/MigrationConstraint.ts b/scenario/constraints/MigrationConstraint.ts
@@ -15,7 +15,7 @@ async function getMigrations<T>(world: World): Promise<Migration<T>[]> {
 }
 
 async function isEnacted<T>(actions: Actions<T>, dm: DeploymentManager, govDm: DeploymentManager): Promise<boolean> {
-  return actions.enacted && await actions.enacted(dm, govDm);
+  return actions.enacted ? await actions.enacted(dm, govDm) : false;
 }
 
 export class MigrationConstraint<T extends CometContext> implements StaticConstraint<T> {
@@ -76,10 +76,12 @@ export class VerifyMigrationConstraint<T extends CometContext> implements Static
     return [
       async function (ctx: T): Promise<T> {
         const govDeploymentManager = ctx.world.auxiliaryDeploymentManager || ctx.world.deploymentManager;
-        for (const migration of ctx.migrations) {
-          if (migration.actions.verify && !(await isEnacted(migration.actions, ctx.world.deploymentManager, govDeploymentManager))) {
-            await migration.actions.verify(ctx.world.deploymentManager, govDeploymentManager);
-            debug(`${label} Verified migration "${migration.name}"`);
+        if (ctx.migrations) {
+          for (const migration of ctx.migrations) {
+            if (migration.actions.verify && !(await isEnacted(migration.actions, ctx.world.deploymentManager, govDeploymentManager))) {
+              await migration.actions.verify(ctx.world.deploymentManager, govDeploymentManager);
+              debug(`${label} Verified migration "${migration.name}"`);
+            }
           }
         }
         return ctx;

diff --git a/scenario/constraints/ModernConstraint.ts b/scenario/constraints/ModernConstraint.ts
@@ -1,12 +1,13 @@
 import { Constraint } from '../../plugins/scenario';
+import { Solution } from '../../plugins/scenario/Scenario';
 import { CometContext } from '../context/CometContext';
 import { getFuzzedRequirements } from './Fuzzing';
 import { Requirements } from './Requirements';
 
 export class ModernConstraint<T extends CometContext, R extends Requirements> implements Constraint<T, R> {
   async solve(requirements: R, _context: T) {
     const fuzzed = await getFuzzedRequirements(requirements);
-    const solutions = [];
+    const solutions: Solution<T>[] = [];
     for (const req of fuzzed) {
       if (req.upgrade) {
         solutions.push(async function solution(ctx: T): Promise<T> {

diff --git a/scenario/constraints/NativeTokenConstraint.ts b/scenario/constraints/NativeTokenConstraint.ts
@@ -8,7 +8,7 @@ export class NativeTokenConstraint<T extends CometContext> implements StaticCons
       async function (ctx: T): Promise<T> {
         for (const symbol in ctx.assets) {
           const contract = await ctx.world.deploymentManager.contract(symbol);
-          if (contract['deposit()']) {
+          if (contract && contract['deposit()']) {
             const whales = await ctx.getWhales();
             const amount = exp(200_000, await contract.decimals());
             // can make this more sophisticated as needed...

diff --git a/scenario/constraints/ProposalConstraint.ts b/scenario/constraints/ProposalConstraint.ts
@@ -14,9 +14,10 @@ async function getOpenProposals(deploymentManager: DeploymentManager, governor:
   const block = await deploymentManager.hre.ethers.provider.getBlockNumber();
   const filter = governor.filters.ProposalCreated();
   const logs = await fetchLogs(governor, filter, block - searchBlocks, block);
-  const proposals = [];
+  const proposals: OpenProposal[] = [];
   if (logs) {
     for (let log of logs) {
+      if (log.args === undefined) continue;
       const [id, , , , , , startBlock, endBlock] = log.args;
       const state = await governor.state(id);
       if ([

diff --git a/scenario/constraints/SupplyCapConstraint.ts b/scenario/constraints/SupplyCapConstraint.ts
@@ -1,4 +1,4 @@
-import { Constraint } from '../../plugins/scenario';
+import { Constraint, Solution } from '../../plugins/scenario';
 import { CometContext } from '../context/CometContext';
 import { expect } from 'chai';
 import { Requirements } from './Requirements';
@@ -9,7 +9,7 @@ export class SupplyCapConstraint<T extends CometContext, R extends Requirements>
   async solve(requirements: R, _initialContext: T) {
     const supplyCaps = requirements.supplyCaps;
     if (supplyCaps !== undefined) {
-      const solutions = [];
+      const solutions: Solution<T>[] = [];
       solutions.push(async function barelyMeet(context: T) {
         const supplyAmountPerAsset = {};
         for (const [assetName, rawAmount] of Object.entries(supplyCaps)) {
@@ -23,6 +23,8 @@ export class SupplyCapConstraint<T extends CometContext, R extends Requirements>
         return context;
       });
       return solutions;
+    } else {
+      return null;
     }
   }
 

diff --git a/scenario/constraints/TokenBalanceConstraint.ts b/scenario/constraints/TokenBalanceConstraint.ts
@@ -1,4 +1,4 @@
-import { Constraint } from '../../plugins/scenario';
+import { Constraint, Solution } from '../../plugins/scenario';
 import { CometContext } from '../context/CometContext';
 import { expect } from 'chai';
 import { Requirements } from './Requirements';
@@ -29,7 +29,7 @@ export class TokenBalanceConstraint<T extends CometContext, R extends Requiremen
 
       // XXX ideally when properties fail
       //  we can report the names of the solution which were applied
-      const solutions = [];
+      const solutions: Solution<T>[] = [];
       solutions.push(async function barelyMeet(context: T) {
         for (const assetName in actorsByAsset) {
           const asset = await getAssetFromName(assetName, context);
@@ -45,6 +45,8 @@ export class TokenBalanceConstraint<T extends CometContext, R extends Requiremen
         return context;
       });
       return solutions;
+    } else {
+      return null;
     }
   }
 

diff --git a/scenario/constraints/UtilizationConstraint.ts b/scenario/constraints/UtilizationConstraint.ts
@@ -27,7 +27,7 @@ interface UtilizationConfig {
   utilization?: number;
 }
 
-function getUtilizationConfig(requirements: object): UtilizationConfig | null {
+function getUtilizationConfig(requirements: object): UtilizationConfig {
   return {
     utilization: optionalNumber(requirements, 'utilization'),
   };
@@ -52,15 +52,15 @@ export class UtilizationConstraint<T extends CometContext, R extends Requirement
   async solve(requirements: R, _context: T) {
     let { utilization } = getUtilizationConfig(requirements);
 
-    if (utilization == null) {
+    if (utilization === undefined) {
       return null;
     } else {
       // utilization is target number
       return async (context: T): Promise<T> => {
         let comet = await context.getComet();
 
         let baseToken = context.getAssetByAddress(await comet.baseToken());
-        let utilizationFactor = factor(utilization);
+        let utilizationFactor = factor(utilization!);
         let totalSupplyBase = (await comet.totalSupply()).toBigInt();
         let totalBorrowBase = (await comet.totalBorrow()).toBigInt();
 
@@ -93,9 +93,7 @@ export class UtilizationConstraint<T extends CometContext, R extends Requirement
         // everything will come out as zero.
         if (toSupplyBase > 0n) {
           // Add some supply, any amount will do
-          let supplyActor = await context.allocateActor('UtilizationConstraint{Supplier}', {
-            toSupplyBase,
-          });
+          let supplyActor = await context.allocateActor('UtilizationConstraint{Supplier}');
 
           await baseToken.approve(supplyActor, comet);
           await context.sourceTokens(toSupplyBase, baseToken, supplyActor);