@defisaver/sdk 1.0.1 → 1.0.2

package/.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": []
+}

package/.eslintrc.js

@@ -0,0 +1,100 @@
+
+module.exports = {
+  extends: ['airbnb'],
+  plugins: ['import'],
+  parser: '@babel/eslint-parser',
+  env: {
+    es6: true,
+    browser: true,
+  },
+  overrides: [{
+    // these are overrides for .ts files, meaning these are only applied to .ts files
+    files: ['*.ts', '*.tsx'],
+    extends: ['airbnb-typescript'],
+    plugins: ['@typescript-eslint'],
+    parser: '@typescript-eslint/parser',
+    parserOptions: { project: ['./tsconfig.json'] },
+    // typescript rules must be added here to work
+    rules: {
+      '@typescript-eslint/no-unused-vars': 0,
+      '@typescript-eslint/naming-convention': 0,
+      '@typescript-eslint/default-param-last': 0,
+    },
+  }],
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module',
+  },
+  rules: {
+    'no-restricted-syntax': 0,
+    'no-continue': 0,
+    'jsx-a11y/control-has-associated-label': 0,
+    'arrow-parens': 0,
+    'no-async-promise-executor': 0,
+    'no-multiple-empty-lines': [2, { max: 2 }],
+    camelcase: [2, { allow: ['^UNSAFE_'] }],
+    'no-mixed-operators': [2, { allowSamePrecedence: true }],
+    'no-plusplus': 0,
+    'no-minusminus': 0,
+    'prefer-destructuring': 0,
+    'max-len': 0,
+    'class-methods-use-this': 0,
+    'jsx-a11y/href-no-hash': 'off',
+    'jsx-a11y/no-autofocus': 0,
+    'no-unused-vars': 0,
+    'no-underscore-dangle': 0,
+    'global-require': 0,
+    'no-console': 0,
+    'new-cap': 0,
+    'eol-last': 0,
+    'jsx-a11y/label-has-for': 0,
+    'linebreak-style': 0,
+    'consistent-return': 0,
+    'import/prefer-default-export': 0,
+    'no-unescaped-entities': 0,
+    'jsx-a11y/no-static-element-interactions': 0,
+    'jsx-a11y/click-events-have-key-events': 0,
+    'jsx-a11y/anchor-is-valid': 0,
+    'no-shadow': 0,
+    'prefer-promise-reject-errors': 0,
+    'function-paren-newline': 0,
+    'operator-linebreak': 0,
+    'jsx-a11y/no-noninteractive-element-interactions': 0,
+    'jsx-a11y/label-has-associated-control': 0,
+    'no-nested-ternary': 0,
+    'import/no-cycle': 0,
+    'import/no-unresolved': 0,
+    'function-call-argument-newline': 0,
+    'import/extensions': [
+      'error',
+      'always',
+      {
+        pattern: {
+          js: 'never',
+          ts: 'never',
+        },
+      },
+    ],
+  },
+  globals: {
+    web3: true,
+    ethereum: true,
+    $: true,
+    window: true,
+    document: true,
+    fetch: true,
+    location: true,
+    localStorage: true,
+  },
+  settings: {
+    'import/resolver': {
+      typescript: {
+        alwaysTryTypes: true,
+        project: ['./tsconfig.json'],
+      },
+      node: {
+        extensions: ['.js', '.ts'],
+      },
+    },
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/sdk",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "./umd/index.js",
   "module": "./esm/src/index.js",
@@ -25,11 +25,13 @@
     "@types/web3-eth-abi": "^1.2.2",
     "axios": "^0.21.1",
     "decimal.js": "^10.2.1",
+    "web3": "^1.8.0",
     "web3-eth-abi": "^1.8.0",
     "web3-utils": "^1.8.0"
   },
   "devDependencies": {
     "@babel/core": "^7.12.10",
+    "@babel/eslint-parser": "^7.12.17",
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-typescript": "^7.12.7",
     "@types/node": "^18.11.8",
@@ -38,7 +40,11 @@
     "babel-loader": "^8.2.2",
     "chai": "^4.2.0",
     "dotenv": "^10.0.0",
-    "eslint": "^8.26.0",
+    "eslint": "8.22.0",
+    "eslint-config-airbnb": "^18.0.2",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-import-resolver-typescript": "^3.5.1",
+    "eslint-plugin-import": "^2.22.0",
     "jsdoc-to-markdown": "^6.0.1",
     "mocha": "^8.2.1",
     "ts-node": "^10.9.1",
@@ -47,7 +53,6 @@
     "typescript": "^4.8.4",
     "webpack": "^5.13.0",
     "webpack-cli": "^4.10.0",
-    "web3": "^1.8.0",
     "@types/web3": "^1.2.2"
   }
 }

package/src/Action.ts

@@ -2,24 +2,26 @@ import AbiCoder from 'web3-eth-abi';
 import { keccak256, padLeft, toHex } from 'web3-utils';
 import { CONFIG } from './config';
 import ActionAbi from './abis/Action.json';
-import { AccessLists as _AccessLists,AccessListItem} from './types';
+import { AccessLists as _AccessLists, AccessListItem, EthAddress } from './types';
 import { AccessLists } from '../AccessLists';
-import { EthAddress } from './types';
 
 type ParamTypes = Array<string | Array<any>>;
 type Args = Array<any>;
 
 /**
  * Single action that can be executed directly, or combined into a set (ie. supply a vault)
- * 
+ *
  * @category Base Classes
  */
 export class Action {
-
   contractAddress : EthAddress;
+
   paramTypes: ParamTypes;
+
   name: string;
+
   args: Args;
+
   mappableArgs: Args;
 
   /**
@@ -31,7 +33,7 @@ export class Action {
   constructor(name: string, contractAddress: EthAddress, paramTypes : ParamTypes, args : Args) {
     // if (new.target === Action) throw new TypeError("Actions are instantiated using derived classes");
 
-    if (paramTypes.length !== args.length) throw new Error('Parameters/arguments length mismatch')
+    if (paramTypes.length !== args.length) throw new Error('Parameters/arguments length mismatch');
 
     this.contractAddress = contractAddress;
     this.paramTypes = paramTypes;
@@ -41,26 +43,28 @@ export class Action {
   }
 
   /**
-   * 
+   *
    */
   getId() : string {
     return keccak256(this.name).substr(0, 10);
   }
 
   /**
-   * 
+   *
    */
-  #_getArgumentMappingWithSlots(subSlots: Args) : Array<number>{
+  #_getArgumentMappingWithSlots(subSlots: Args) : Array<number> {
     return this.mappableArgs.map(arg => {
       if (new RegExp(/\$\d+/).test(arg)) {
         if (Array.isArray(arg)) throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
-        return parseInt(arg.substr(1))
+        // eslint-disable-next-line
+        return parseInt(arg.substr(1));
       }
 
       // Handle SubSlots placeholder values in strategies
       if (new RegExp(/&\w+/).test(arg)) {
         if (arg === '&proxy') return 254;
         if (arg === '&eoa') return 255;
+        // eslint-disable-next-line
         return parseInt(subSlots[arg].index);
       }
 
@@ -68,25 +72,27 @@ export class Action {
     });
   }
 
-   /**
-   * 
+  /**
+   *
    */
-    _getArgumentMapping() : Args {
-      return this.mappableArgs.map(arg => {
-        if (new RegExp(/\$\d+/).test(arg)) {
-          if (Array.isArray(arg)) throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
-          return parseInt(arg.substr(1))
-        }
-        return 0;
-      });
-    }
+  _getArgumentMapping() : Args {
+    return this.mappableArgs.map(arg => {
+      if (new RegExp(/\$\d+/).test(arg)) {
+        if (Array.isArray(arg)) throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
+        // eslint-disable-next-line
+        return parseInt(arg.substr(1));
+      }
+      return 0;
+    });
+  }
 
   /**
    * @param type
-   * 
+   *
    */
   #_getPlaceholderForType(type: string) : string {
     // TODO handle arrays?
+    // eslint-disable-next-line
     if (type.startsWith('bytes')) return `0x${'0'.repeat(parseInt(type.substr(5)))}`;
     if (type === 'address') return `0x${'0'.repeat(40)}`;
     if (type === 'string') return '';
@@ -94,19 +100,19 @@ export class Action {
   }
 
   /**
-   * 
+   *
    */
   _replaceWithPlaceholders(arg: Args, paramType: string | ParamTypes) : any {
     if (Array.isArray(arg)) return arg.map((_arg, i) => this._replaceWithPlaceholders(_arg, paramType[i]));
-    if(typeof(paramType) === 'string'){
-        if (new RegExp(/\$\d+/).test(arg)) return this.#_getPlaceholderForType(paramType);
-        if (new RegExp(/&\w+/).test(arg)) return this.#_getPlaceholderForType(paramType);
+    if (typeof (paramType) === 'string') {
+      if (new RegExp(/\$\d+/).test(arg)) return this.#_getPlaceholderForType(paramType);
+      if (new RegExp(/&\w+/).test(arg)) return this.#_getPlaceholderForType(paramType);
     }
     return arg;
   }
 
   /**
-   * 
+   *
    */
   _formatType(paramType: string | ParamTypes) : string {
     if (Array.isArray(paramType)) return `(${paramType.map((_paramType) => this._formatType(_paramType))})`;
@@ -116,7 +122,7 @@ export class Action {
   /**
    * Encode arguments for calling the action directly
    * @returns bytes-encoded args
-   * 
+   *
    */
   _encodeForCall() : Array<string> {
     const _arg = this._replaceWithPlaceholders(this.args, this.paramTypes);
@@ -136,42 +142,41 @@ export class Action {
    * Encode arguments for calling the action via DsProxy
    * @returns `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
    */
-  encodeForDsProxyCall() : Array<string | string[]>{
+  encodeForDsProxyCall() : Array<string | string[]> {
     if (CONFIG.chainId === 1) {
-      const executeActionDirectAbi : any = (ActionAbi.find(({ name }:{name: string}) => name === 'executeActionDirect'))!;
+      const executeActionDirectAbi : any = (ActionAbi.find(({ name }:{ name: string }) => name === 'executeActionDirect'))!;
       return [
         this.contractAddress,
         AbiCoder.encodeFunctionCall(executeActionDirectAbi, this._encodeForCall()),
       ];
-    } else {
-      return [this.contractAddress, this.encodeForL2DsProxyCall()];
     }
+    return [this.contractAddress, this.encodeForL2DsProxyCall()];
   }
 
   /**
    * Encodes action for Recipe call
    */
   encodeForRecipe() : Array<string | string[] | number[]> {
-      return [
-        this._encodeForCall()[0],  // actionCallData
-        "0x0000000000000000000000000000000000000000000000000000000000000000", // subData
-        this.getId(),              // actionIds
-        this._getArgumentMapping(), // paramMappings
-      ]
+    return [
+      this._encodeForCall()[0], // actionCallData
+      '0x0000000000000000000000000000000000000000000000000000000000000000', // subData
+      this.getId(), // actionIds
+      this._getArgumentMapping(), // paramMappings
+    ];
   }
 
-  encodeForStrategy(subSlots: any) : Array<(string | number[])>{
+  encodeForStrategy(subSlots: any) : Array<(string | number[])> {
     return [
       this.getId(),
       this.#_getArgumentMappingWithSlots(subSlots), // paramMappings
-    ]
+    ];
   }
 
   /**
    * Assets requiring approval to be used by DsProxy
    * Approval is done from owner to DsProxy
    */
-  async getAssetsToApprove(): Promise<Array<{owner?: string, asset?: string,[key: string]:any}>> {
+  async getAssetsToApprove(): Promise<Array<{ owner?: string, asset?: string, [key: string]:any }>> {
     return [];
   }
 
@@ -187,12 +192,12 @@ export class Action {
    * Access list for single action
    */
   getAccessList(chainId: number) : Array<AccessListItem> {
-    if(chainId!=1) return [];
+    if (chainId !== 1) return [];
     return [
       [this.contractAddress, []],
       ...(AccessLists[this.name as keyof _AccessLists] || []),
     ].map(([address, storageKeys]) => ({
-      address: address,
+      address,
       storageKeys: storageKeys.map((num: number) => padLeft(toHex(num), 64)),
     }));
   }

package/src/ActionWithL2.ts

@@ -1,11 +1,11 @@
-import {Action} from './Action';
 import Dec from 'decimal.js';
 import AbiCoder from 'web3-eth-abi';
+import { Action } from './Action';
 import ActionAbi from './abis/Action.json';
 
 /**
  * Single L2 action that can be executed directly, or combined into a set (ie. supply a vault)
- * 
+ *
  * @category Base Classes
  */
 export class ActionWithL2 extends Action {
@@ -25,21 +25,21 @@ export class ActionWithL2 extends Action {
 
   addressToBytes20(address:string) { return address.slice(2); }
 
-  boolToBytes1(bool:boolean) { return bool ? '01' : '00' }
+  boolToBytes1(bool:boolean) { return bool ? '01' : '00'; }
 
   async getEthValue() { return '0'; }
 
-  numberToBytes2(number:number){
+  numberToBytes2(number:number) {
     const hexNumber = number.toString(16);
     return hexNumber.padStart(4, '0');
   }
 
-  numberToBytes1(number:number){
+  numberToBytes1(number:number) {
     const hexNumber = number.toString(16);
     return hexNumber.padStart(2, '0');
   }
 
-  numberToBytes32(number:number){
+  numberToBytes32(number:number) {
     let hexNumber = new Dec(number).toHex();
     hexNumber = hexNumber.slice(2);
 

package/src/DfsWeb3.ts

@@ -1,25 +1,27 @@
+import Web3 from 'web3';
+import { AbiItem, StateMutabilityType, AbiType } from 'web3-utils';
 import DFSPRoxyRegistyAbi from './abis/DFSProxyRegistry.json';
 import ProxyRegistryAbi from './abis/ProxyRegistry.json';
 import DsProxyAbi from './abis/DsProxy.json';
 import Erc20Abi from './abis/Erc20.json';
 import { getAddr } from './addresses';
-import {Action}  from "./Action";
-import {Recipe} from "./Recipe";
+import { Action } from './Action';
+import { Recipe } from './Recipe';
 import { CONFIG } from './config';
 import { EthAddress } from './types';
 // reports error but it works ?????
-import Web3 from 'web3';
-import { AbiItem, StateMutabilityType, AbiType } from 'web3-utils';
 
 /**
- * 
+ *
  * @category Base Classes
  */
 export class DfsWeb3 {
-
   web3: Web3;
+
   accountReady: boolean;
+
   account?: EthAddress;
+
   proxy?: EthAddress;
 
   constructor(web3: Web3) {
@@ -42,10 +44,8 @@ export class DfsWeb3 {
     const accounts = await this.web3.eth.getAccounts();
     if (!accounts || !accounts.length) throw new Error('Supplied web3 has no account');
     this.account = accounts[0];
-    const DFSPRoxyRegistyAbiItems : AbiItem[] = DFSPRoxyRegistyAbi.map(item=>{
-      return {...item,stateMutability: item.stateMutability as StateMutabilityType,type: item.type as AbiType};
-    });
-    const dfsRegistry = new this.web3.eth.Contract(DFSPRoxyRegistyAbiItems, getAddr('DFSProxyRegistry',CONFIG.chainId));
+    const DFSPRoxyRegistyAbiItems : AbiItem[] = DFSPRoxyRegistyAbi.map(item => ({ ...item, stateMutability: item.stateMutability as StateMutabilityType, type: item.type as AbiType }));
+    const dfsRegistry = new this.web3.eth.Contract(DFSPRoxyRegistyAbiItems, getAddr('DFSProxyRegistry', CONFIG.chainId));
     const proxies = await dfsRegistry.methods.getAllProxies(this.account).call();
     if (proxies[0] !== '0x0000000000000000000000000000000000000000') {
       this.proxy = proxies[0];
@@ -57,10 +57,8 @@ export class DfsWeb3 {
     if (!this.accountReady) await this.prepareAccount();
     if (!this.account) throw new Error('DfsWeb3 has not been instantiated properly');
     if (this.proxy) throw new Error('Account already has DsProxy');
-    const ProxyRegistryAbiItems : AbiItem[] = ProxyRegistryAbi.map(item=>{
-      return {...item,stateMutability: item.stateMutability as StateMutabilityType,type: item.type as AbiType};
-    });
-    const makerRegistry = new this.web3.eth.Contract(ProxyRegistryAbiItems, getAddr('ProxyRegistry',CONFIG.chainId));
+    const ProxyRegistryAbiItems : AbiItem[] = ProxyRegistryAbi.map(item => ({ ...item, stateMutability: item.stateMutability as StateMutabilityType, type: item.type as AbiType }));
+    const makerRegistry = new this.web3.eth.Contract(ProxyRegistryAbiItems, getAddr('ProxyRegistry', CONFIG.chainId));
     return makerRegistry.methods.build();
   }
 
@@ -74,9 +72,7 @@ export class DfsWeb3 {
     const approvals = await action.getAssetsToApprove();
     await Promise.all(approvals.map(async (a) => {
       if (a.owner!.toLowerCase() === this.proxy!.toLowerCase()) {
-        const Erc20AbiItems : AbiItem[] = Erc20Abi.map(item=>{
-          return {...item,stateMutability: item.stateMutability as StateMutabilityType,type: item.type as AbiType};
-        });
+        const Erc20AbiItems : AbiItem[] = Erc20Abi.map(item => ({ ...item, stateMutability: item.stateMutability as StateMutabilityType, type: item.type as AbiType }));
         const tokenContract = new this.web3.eth.Contract(Erc20AbiItems, a.asset);
         const allowance = await tokenContract.methods.allowance(this.account, this.proxy).call();
         if (parseFloat(allowance.toString()) === 0) {
@@ -90,9 +86,7 @@ export class DfsWeb3 {
   async execute(address: EthAddress, params: Array<any>) {
     if (!this.accountReady) await this.prepareAccount();
     if (!this.proxy) throw new Error('Account does not have a Smart Wallet. Run createSmartWallet first');
-    const DsProxyAbiItems : AbiItem[] = DsProxyAbi.map(item=>{
-      return {...item,stateMutability: item.stateMutability as StateMutabilityType,type: item.type as AbiType};
-    });
+    const DsProxyAbiItems : AbiItem[] = DsProxyAbi.map(item => ({ ...item, stateMutability: item.stateMutability as StateMutabilityType, type: item.type as AbiType }));
     const proxyContract = new this.web3.eth.Contract(DsProxyAbiItems, this.proxy);
     return proxyContract.methods['execute(address,bytes)'](address, params);
   }
@@ -101,14 +95,15 @@ export class DfsWeb3 {
    * @param action
    */
   async executeAction(action: Action) : Promise<Action> {
-    const encoded =action.encodeForDsProxyCall();
-    return this.execute(encoded[0] as string,encoded[1] as string[]);
+    const encoded = action.encodeForDsProxyCall();
+    return this.execute(encoded[0] as string, encoded[1] as string[]);
   }
+
   /**
    * @param recipe
    */
   async executeRecipe(recipe: Recipe) : Promise<Recipe> {
-    const encoded =recipe.encodeForDsProxyCall();
-    return this.execute(encoded[0] as string,encoded[1] as unknown as string[]);
+    const encoded = recipe.encodeForDsProxyCall();
+    return this.execute(encoded[0] as string, encoded[1] as unknown as string[]);
   }
-}
+}

package/src/Recipe.ts

@@ -1,10 +1,10 @@
 import AbiCoder from 'web3-eth-abi';
-import {toBN} from 'web3-utils';
-import {getAssetInfo, utils} from "@defisaver/tokens";
-import {Action}  from './Action';
+import { toBN } from 'web3-utils';
+import { getAssetInfo, utils } from '@defisaver/tokens';
+import { Action } from './Action';
 import { getAddr } from './addresses';
 import RecipeAbi from './abis/Recipe.json';
-import {AccessListItem, EthAddress} from './types';
+import { AccessListItem, EthAddress } from './types';
 import { CONFIG } from './config';
 
 /**
@@ -13,10 +13,12 @@ import { CONFIG } from './config';
  * @category Base Classes
  */
 export class Recipe {
-
   name: string;
+
   actions: Array<Action>;
+
   recipeExecutorAddress: string;
+
   extraGas: number;
 
   /**
@@ -32,7 +34,7 @@ export class Recipe {
     this.actions = actions;
 
     this.extraGas = 0;
-    this.recipeExecutorAddress = getAddr('RecipeExecutor',CONFIG.chainId);
+    this.recipeExecutorAddress = getAddr('RecipeExecutor', CONFIG.chainId);
   }
 
   /**
@@ -48,7 +50,7 @@ export class Recipe {
    * Encode arguments for calling the action set directly
    *
    */
-  #_encodeForCall(): Array<string|Array<any>> {
+  #_encodeForCall(): Array<string | Array<any>> {
     const encoded = this.actions.map(action => action.encodeForRecipe());
     const transposed = encoded[0].map((_, colIndex) => encoded.map(row => row[colIndex]));
     const taskStruct = [
@@ -63,7 +65,7 @@ export class Recipe {
    * @returns `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
    */
   encodeForDsProxyCall() : Array<string> {
-    const executeTaskAbi : any = RecipeAbi.find(({name}:{name: string}) => name === 'executeRecipe');
+    const executeTaskAbi : any = RecipeAbi.find(({ name }:{ name: string }) => name === 'executeRecipe');
     const encoded = this.#_encodeForCall();
     return [
       this.recipeExecutorAddress,
@@ -79,7 +81,7 @@ export class Recipe {
     this.actions.forEach((action : Action, i : number) => {
       action._getArgumentMapping().forEach((source, j) => {
         if (source) console.log(`${this.actions[i].name} takes argument #${j + 1} from ${this.actions[source - 1].name} (action #${source})`);
-      })
+      });
     });
   }
 
@@ -87,14 +89,14 @@ export class Recipe {
    * Assets requiring approval to be used by DsProxy
    * Approval is done from owner to DsProxy
    */
-  async getAssetsToApprove() : Promise<Array<{owner: string, asset: string}>> {
-    const uniqueAssetOwnerPairs : Array<{owner: string, asset: string,[key: string]:any}> = [];
+  async getAssetsToApprove() : Promise<Array<{ owner: string, asset: string }>> {
+    const uniqueAssetOwnerPairs : Array<{ owner: string, asset: string, [key: string]:any }> = [];
     const assetOwnerPairs = await Promise.all(this.actions.map(a => a.getAssetsToApprove()));
     for (const pairsPerAction of assetOwnerPairs) {
       for (const pair of pairsPerAction) {
         const isNft = !pair.asset;
         if (!uniqueAssetOwnerPairs.find(_pair => _pair.owner === pair.owner && (isNft ? _pair.tokenId === pair.tokenId : _pair.asset === pair.asset))) {
-          uniqueAssetOwnerPairs.push({owner:pair.owner!,asset:pair.asset!});
+          uniqueAssetOwnerPairs.push({ owner: pair.owner!, asset: pair.asset! });
         }
       }
     }
@@ -116,14 +118,14 @@ export class Recipe {
    */
   getAccessList(): Array<AccessListItem> {
     const addressMapping : any = {
-      [getAddr('RecipeExecutor',CONFIG.chainId)]: [],
-      [getAddr('DFSRegistry',CONFIG.chainId)]: [],
+      [getAddr('RecipeExecutor', CONFIG.chainId)]: [],
+      [getAddr('DFSRegistry', CONFIG.chainId)]: [],
     };
     this.actions.forEach((action) => {
       const accessList = action.getAccessList(CONFIG.chainId);
-      accessList.forEach(({ address, storageKeys }:{address: EthAddress,storageKeys: Array<string>}) => {
+      accessList.forEach(({ address, storageKeys }:{ address: EthAddress, storageKeys: Array<string> }) => {
         addressMapping[address] = new Set([...storageKeys, ...(addressMapping[address] || [])]);
-      })
+      });
     });
     return Object.keys(addressMapping).map((address) => ({
       address,

package/src/Strategy.ts

@@ -1,15 +1,18 @@
-import {Action}  from './Action';
+import { Action } from './Action';
 
 /**
- * 
+ *
  * @category Base Classes
  */
 export class Strategy {
-
   name: string;
+
   subSlots: any;
+
   actions: Array<Action>;
+
   triggers: Array<Action>;
+
   numSubSlots: number;
 
   constructor(name: string) {
@@ -21,7 +24,7 @@ export class Strategy {
   }
 
   addSubSlot(name: string, type: string) {
-    this.subSlots[name] = { type, index:  this.numSubSlots + 128 };
+    this.subSlots[name] = { type, index: this.numSubSlots + 128 };
     this.numSubSlots++;
   }
 
@@ -34,8 +37,8 @@ export class Strategy {
   }
 
   print() {
-    console.log(`Name: ${this.name }`);
-    console.log(`Slots: ${this.subSlots }`);
+    console.log(`Name: ${this.name}`);
+    console.log(`Slots: ${this.subSlots}`);
     console.log(`Action: ${this.actions[0]}`);
   }
 
@@ -60,8 +63,7 @@ export class Strategy {
       this.name,
       triggerIds,
       actionIds,
-      paramMappings
+      paramMappings,
     ];
   }
-
 }

package/src/actions/aave/AaveBorrowAction.ts

@@ -1,11 +1,11 @@
-import {Action}  from "../../Action";
-import { requireAddress } from "../../utils/general";
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * AaveBorrowAction - Borrow tokens from Aave
- * 
+ *
  * @category Aave
  */
 export class AaveBorrowAction extends Action {