@defisaver/sdk 0.1.7 → 0.1.11

package/test/accessLists/Recipe.js

@@ -0,0 +1,123 @@
+const AbiCoder = require('web3-eth-abi');
+const { BN } = require('web3-utils');
+const {getAssetInfo, utils: {compare}} = require("@defisaver/tokens");
+const Action = require('../../src/Action');
+const {getAddr} = require('../../src/addresses');
+const RecipeAbi = require('../../src/abis/Recipe.json');
+const MockAccessLists = require('./MockAccessLists');
+
+/**
+ * Set of Actions to be performed sequentially in a single transaction
+ */
+class Recipe {
+  /**
+   * @param name {string}
+   * @param actions {Array<Action>}
+   */
+  constructor(name, actions = []) {
+    actions.forEach((action) => {
+      if (!action instanceof Action) throw new TypeError('Supplied action does not inherit Action');
+    });
+
+    this.name = name;
+    this.actions = actions;
+    this.taskExecutorAddress = getAddr('TaskExecutor');
+  }
+
+  /**
+   * @param action {Action}
+   * @returns {Recipe}
+   */
+  addAction(action) {
+    if (!action instanceof Action) throw new TypeError('Supplied action does not inherit Action');
+    this.actions.push(action);
+    return this;
+  }
+
+  /**
+   * Encode arguments for calling the action set directly
+   * @returns {Array<string|Array<*>>}
+   * @private
+   */
+  _encodeForCall() {
+    const encoded = this.actions.map(action => action.encodeForRecipe());
+    const transposed = encoded[0].map((_, colIndex) => encoded.map(row => row[colIndex]));
+    const taskStruct = [
+      this.name,
+      ...transposed,
+    ];
+    return [taskStruct];
+  }
+
+  /**
+   * Encode arguments for calling the action set via DsProxy
+   * @returns {Array<string>} `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
+   */
+  encodeForDsProxyCall() {
+    const executeTaskAbi = RecipeAbi.find(({name}) => name === 'executeTask');
+    return [
+      this.taskExecutorAddress,
+      AbiCoder.encodeFunctionCall(executeTaskAbi, this._encodeForCall()),
+    ];
+  }
+
+  /**
+   * Logs parameter mapping in verbose format for validation. Used for testing in development.
+   */
+  _validateParamMappings() {
+    this.actions.forEach((action, i) => {
+      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})`);
+      })
+    });
+  }
+
+  /**
+   * Assets requiring approval to be used by DsProxy
+   * Approval is done from owner to DsProxy
+   * @returns {Promise<Array<{owner: string, asset: string}>>}
+   */
+  async getAssetsToApprove() {
+    const uniqueAssetOwnerPairs = [];
+    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(pair);
+        }
+      }
+    }
+    return uniqueAssetOwnerPairs.filter(({ address }) => !compare(address, getAssetInfo('ETH').address));
+  }
+
+  /**
+   * ETH value to be sent with transaction
+   * @returns {Promise<string>} ETH value in wei
+   */
+  async getEthValue() {
+    return (await Promise.all(this.actions.map(a => a.getEthValue())))
+      .reduce((acc, val) => acc.add(new BN(val)), new BN(0))
+      .toString();
+  }
+
+  /**
+   * Generates an access list for the recipe
+   * @returns {Array<*>}
+   */
+  getAccessList() {
+    const addressMapping = {
+      [getAddr('TaskExecutor')]: [],
+      [getAddr('DFSRegistry')]: [],
+    };
+    this.actions.forEach((action) => {
+      const accessList = MockAccessLists[action.name];
+      accessList.forEach(([address, memoryLocations]) => {
+        addressMapping[address] = new Set([...memoryLocations, ...(addressMapping[address] || [])]);
+      })
+    });
+    return Object.keys(addressMapping).map((addr) => [addr, [...addressMapping[addr]]]);
+  }
+}
+
+module.exports = Recipe;

package/test/accessLists/access-lists.js

@@ -0,0 +1,101 @@
+const { assert } = require("chai");
+const dfs = require("../../index.js");
+const Recipe = require("./Recipe");
+const MockAccessLists = require('./MockAccessLists');
+
+const testDuplicates = (accessList) => {
+    const contractAddrs = accessList.map((entry) => {
+        assert(
+            entry[1].length == [...new Set(entry[1])].length,
+            'Duplicate storage address found',
+        );
+        return entry[0];
+    })
+
+    assert(
+        accessList.length == [...new Set(contractAddrs)].length,
+        'Duplicate contract address found',
+    );
+
+    return true;
+};
+
+const testInclusion = (recipe, accessList) => {
+    const actions = recipe.actions;
+    const addressMapping = Object.fromEntries(accessList);
+    actions.forEach((action) => {
+        MockAccessLists[action.name].forEach((entry) => {
+            const storageAddrs = new Set(addressMapping[entry[0]]);
+            assert(
+                storageAddrs,
+                'Access list missing a contract address',
+            );
+            entry[1].forEach((addr) => {
+                assert(
+                    storageAddrs.has(addr),
+                    'Access list missing a storage address',
+                );
+            })
+        });
+    });
+
+    return true;
+};
+
+const deadbeef = '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef';
+
+const sampleRecipes = [
+    new Recipe('recMakerRepay', [
+        new dfs.actions.maker.MakerWithdrawAction(0, 0, deadbeef, deadbeef),
+        new dfs.actions.basic.SellAction(0, deadbeef, deadbeef, 0),
+        new dfs.actions.maker.MakerPaybackAction(0, '$2', deadbeef, deadbeef),
+    ]),
+    new Recipe('recMakerFLBoost', [
+        new dfs.actions.flashloan.MakerFlashLoanAction(0, deadbeef, ''),
+        new dfs.actions.basic.SellAction('', deadbeef, deadbeef, 0),
+        new dfs.actions.maker.MakerSupplyAction(0, '$2', deadbeef, deadbeef),
+        new dfs.actions.maker.MakerGenerateAction(0, '$1', deadbeef),
+    ]),
+    new Recipe('recMakerFRepayViaDebt', [
+        new dfs.actions.flashloan.MakerFlashLoanAction(0, deadbeef, ''),,
+        new dfs.actions.maker.MakerPaybackAction(0, 0, deadbeef, deadbeef),
+        new dfs.actions.maker.MakerWithdrawAction(0, 0, deadbeef, deadbeef, deadbeef),
+        new dfs.actions.basic.SellAction('', deadbeef, deadbeef, 0),
+        new dfs.actions.basic.SendTokenAction(deadbeef, deadbeef, '$1'),
+    ]),
+    new Recipe('recCompoundFLBoostViaColl', [
+        new dfs.actions.flashloan.MakerFlashLoanAction(0, deadbeef, []),
+        new dfs.actions.compound.CompoundSupplyAction(deadbeef, '$1', deadbeef, true),
+        new dfs.actions.compound.CompoundBorrowAction(deadbeef, 0, deadbeef),
+    ]),
+    new Recipe('recCompoundFLRepayViaDebt', [
+        new dfs.actions.flashloan.MakerFlashLoanAction(0, deadbeef, []),
+        new dfs.actions.compound.CompoundSupplyAction(deadbeef, '$1', deadbeef, true),
+        new dfs.actions.compound.CompoundWithdrawAction(deadbeef, 0, deadbeef),
+    ]),
+];
+
+describe('Access-Lists', () => {
+    sampleRecipes.forEach((recipe) => {
+        it(`... should make an access list for recipe ${recipe.name}`, () => {
+            const recipeAccessList = recipe.getAccessList();
+            testDuplicates(recipeAccessList);
+            testInclusion(recipe, recipeAccessList);
+        });
+    });
+
+    it('... should handle duplicate actions in recipe correctly', () => {
+        const recipe = new Recipe('mockRecipe', [
+            new dfs.actions.flashloan.MakerFlashLoanAction(0, deadbeef, []),
+            new dfs.actions.compound.CompoundSupplyAction(deadbeef, '$1', deadbeef, true),
+            new dfs.actions.compound.CompoundSupplyAction(deadbeef, '$1', deadbeef, true),
+            new dfs.actions.compound.CompoundSupplyAction(deadbeef, '$1', deadbeef, true),
+            new dfs.actions.compound.CompoundSupplyAction(deadbeef, '$1', deadbeef, true),
+            new dfs.actions.compound.CompoundWithdrawAction(deadbeef, 0, deadbeef),
+        ]);
+
+        const recipeAccessList = recipe.getAccessList();
+        testDuplicates(recipeAccessList);
+        testInclusion(recipe, recipeAccessList);
+    });
+});

package/src/actions/aave/AaveMigrateLendAction.js

@@ -1,18 +0,0 @@
-const Action = require("../../Action");
-const { getAddr } = require('../../addresses.js');
-
-/**
- * AaveMigrateLendAction - Migrates Lend to Aave
- */
-class AaveMigrateLendAction extends Action {
-  /**
-   * @param lendAmount {string}
-   * @param from {EthAddress}
-   * @param to {EthAddress}
-   */
-  constructor(lendAmount, from, to) {
-    super('AaveMigrateLend', getAddr('AaveMigrateLend'), ["uint256", "address", "address"], [...arguments]);
-  }
-}
-
-module.exports = AaveMigrateLendAction;