@defisaver/sdk 0.2.11 → 0.3.0

package/index.js

@@ -2,6 +2,9 @@ const Action = require('./src/Action');
 const Recipe = require('./src/Recipe');
 const Strategy = require('./src/Strategy');
 const DfsWeb3 = require('./src/DfsWeb3');
+const {
+  configure, getNetworkData, CONFIG, NETWORKS,
+} = require('./src/config');
 
 const actions = require('./src/actions/');
 const triggers = require('./src/triggers/');
@@ -12,9 +15,15 @@ module.exports = {
   Action,
   Recipe,
   Strategy,
+  DfsWeb3,
+
   actions,
   triggers,
-  actionAddresses,
   utils,
-  DfsWeb3,
+
+  configure,
+  getNetworkData,
+  networks: NETWORKS,
+  actionAddressesAllChains: actionAddresses,
+  actionAddresses: () => actionAddresses[CONFIG.chainId],
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/sdk",
-  "version": "0.2.11",
+  "version": "0.3.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -13,7 +13,7 @@
   "repository": "https://github.com/DecenterApps/defisaver-sdk",
   "license": "ISC",
   "dependencies": {
-    "@defisaver/tokens": "^1.4.12",
+    "@defisaver/tokens": "^1.4.18",
     "@ethersproject/address": "^5.0.10",
     "@ethersproject/solidity": "^5.0.9",
     "axios": "^0.21.1",
@@ -23,9 +23,9 @@
   },
   "devDependencies": {
     "chai": "^4.2.0",
-    "dotenv": "^10.0.0",
     "jsdoc-to-markdown": "^6.0.1",
     "mocha": "^8.2.1",
-    "web3": "^1.3.4"
+    "web3": "^1.3.4",
+    "dotenv": "^10.0.0"
   }
 }

package/src/Action.js

@@ -1,5 +1,6 @@
 const AbiCoder = require('web3-eth-abi');
 const { keccak256, padLeft, toHex } = require('web3-utils');
+const { CONFIG } = require('./config');
 
 const ActionAbi = require('./abis/Action.json');
 
@@ -112,16 +113,24 @@ class Action {
     return [AbiCoder.encodeParameter(_paramType, _arg)];
   }
 
+  encodeForL2DsProxyCall() {
+    throw new Error('Not L2'); // TODO improve this
+  }
+
   /**
    * Encode arguments for calling the action via DsProxy
    * @returns {Array<string>} `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
    */
   encodeForDsProxyCall() {
-    const executeActionDirectAbi = ActionAbi.find(({ name }) => name === 'executeActionDirect');
-    return [
-      this.contractAddress,
-      AbiCoder.encodeFunctionCall(executeActionDirectAbi, this._encodeForCall()),
-    ];
+    if (CONFIG.chainId === 1) {
+      const executeActionDirectAbi = ActionAbi.find(({ name }) => name === 'executeActionDirect');
+      return [
+        this.contractAddress,
+        AbiCoder.encodeFunctionCall(executeActionDirectAbi, this._encodeForCall()),
+      ];
+    } else {
+      return [this.contractAddress, this.encodeForL2DsProxyCall()];
+    }
   }
 
   /**

package/src/ActionWithL2.js

@@ -0,0 +1,36 @@
+const Action = require('./Action');
+const Dec = require('decimal.js');
+
+class ActionWithL2 extends Action {
+  /**
+   * Encode arguments for calling the action via DsProxy
+   * @returns {string}
+   */
+  encodeForL2DsProxyCall() { return this.encodeInputs(); }
+
+  encodeInputs() { throw new Error('Use implementation from specific ActionWithL2'); }
+
+  addressToBytes20(address) { return address.slice(2); }
+
+  boolToBytes1(bool) { return bool ? '01' : '00' }
+
+  async getEthValue() { return '0'; }
+
+  numberToBytes2(number){
+    const hexNumber = number.toString(16);
+    return hexNumber.padStart(4, '0');
+  }
+
+  numberToBytes1(number){
+    const hexNumber = number.toString(16);
+    return hexNumber.padStart(2, '0');
+  }
+
+  numberToBytes32(number){
+    let hexNumber = new Dec(number).toHex();
+    hexNumber = hexNumber.slice(2);
+
+    return hexNumber.padStart(64, '0');
+  }
+}
+module.exports = ActionWithL2;

package/src/actions/aaveV3/AaveV3ATokenPaybackAction.js

@@ -0,0 +1,58 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAssetInfoByAddress } = require("@defisaver/tokens");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3ATokenPaybackAction - Repay Aave V3 debt using aTokens
+ */
+class AaveV3ATokenPaybackAction extends ActionWithL2 {
+  /**
+   * @param useDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param market {EthAddress} Address provider for specific market
+   * @param amount {string} Amount of tokens to be payed back (uint.max for full debt)
+   * @param from {EthAddress} Where are we pulling the payback aTokens from
+   * @param rateMode {number} Type of borrow debt [Stable: 1, Variable: 2]
+   * @param aTokenAddr {EthAddress} address of the aToken to be pulled
+   * @param assetId {number} The id of the underlying asset to be repaid
+   */
+  constructor(useDefaultMarket, market, amount, from, rateMode, aTokenAddr, assetId) {
+    super('AaveV3ATokenPayback', getAddr('AaveV3ATokenPayback'),
+    ['uint256','address','uint8','uint16', 'bool', 'address'],
+    [amount, from, rateMode, assetId, useDefaultMarket, market]
+    );
+
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[5],
+    ];
+    this.addressForApproval = aTokenAddr;
+  }
+
+  async getAssetsToApprove() {
+    const asset = getAssetInfoByAddress(this.addressForApproval);
+    if (asset.symbol !== 'ETH') return [{asset: this.addressForApproval, owner: this.args[2]}];
+    return [];
+  }
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // amount
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[0]));
+    // from
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[1]));
+    // rateMode
+    encodedInput = encodedInput.concat(this.numberToBytes1(this.args[2]));
+    // assetId
+    encodedInput = encodedInput.concat(this.numberToBytes2(this.args[3]));
+    // useDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[4]))
+    if (!this.args[4]){
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[5]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3ATokenPaybackAction;

package/src/actions/aaveV3/AaveV3BorrowAction.js

@@ -0,0 +1,59 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3BorrowAction - Borrow a token from AaveV3
+ */
+class AaveV3BorrowAction extends ActionWithL2 {
+   /**
+   * @param useDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param market {EthAddress} Address provider for specific market
+   * @param amount {string} Amount of tokens to be borrowed
+   * @param to {EthAddress} The address we are sending the borrowed tokens to
+   * @param rateMode {number} Type of borrow debt [Stable: 1, Variable: 2]
+   * @param assetId {number} The id of the token to be borrowed
+   * @param useOnBehalf {boolean} use on behalf or default to proxy
+   * @param [onBehalf] {EthAddress} On whose behalf we borrow the tokens, defaults to proxy
+   */
+  constructor(useDefaultMarket, market, amount, to, rateMode, assetId, useOnBehalf , onBehalf = getAddr('Empty')) {
+    super('AaveV3Borrow', getAddr('AaveV3Borrow'),
+    ['uint256','address','uint8','uint16','bool','bool','address','address'],
+    [amount, to, rateMode, assetId, useDefaultMarket, useOnBehalf, market, onBehalf]
+    );
+
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[6],
+      this.args[7],
+    ];
+  }
+
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // amount
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[0]));
+    // to
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[1]));
+    // rateMode
+    encodedInput = encodedInput.concat(this.numberToBytes1(this.args[2]));
+    // assetId
+    encodedInput = encodedInput.concat(this.numberToBytes2(this.args[3]));
+    // useDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[4]))
+    // useOnBehalf
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[5]));
+    if (!this.args[4]) {
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[6]));
+    }
+    if (this.args[5]) {
+      // onBehalf
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[7]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3BorrowAction;

package/src/actions/aaveV3/AaveV3ClaimRewardsAction.js

@@ -0,0 +1,45 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ *  AaveV3ClaimRewardsAction
+ */
+class AaveV3ClaimRewardsAction extends ActionWithL2 {
+    /**
+   * @param assetsLength {number} Address provider for specific market
+   * @param amount {string} length of two arrays
+   * @param to {EthAddress}
+   * @param reward {EthAddress}
+   * @param assets {Array<EthAddress>}
+   */
+  constructor(assetsLength, amount, to, reward, assets) {
+    super(
+      'AaveV3ClaimRewards',
+      getAddr('AaveV3ClaimRewards'),
+      ['uint8', 'uint256', 'address', 'address', 'address[]'],
+      [assetsLength, amount, to, reward, assets],
+    );
+  }
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // assetsLength
+    encodedInput = encodedInput.concat(this.numberToBytes1(this.args[0]));
+    // amount
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[1]));
+    // to
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[2]));
+    // reward
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[3]));
+    // assets
+    const arrayLength = this.args[0];
+    for (let i = 0; i < arrayLength; i++){
+      // assets[i]
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[4][i]))
+    }
+
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3ClaimRewardsAction;

package/src/actions/aaveV3/AaveV3CollateralSwitchAction.js

@@ -0,0 +1,45 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ *  AaveV3CollateralSwitchAction - Aave enable/disable token usage as collateral for AaveV3 position
+ */
+class AaveV3CollateralSwitchAction extends ActionWithL2 {
+  /**
+   * @param useDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param market {EthAddress} Address provider for specific market
+   * @param arrayLength {number} length of two arrays
+   * @param assetIds {Array<number>}
+   * @param useAsCollateral {Array<boolean>}
+   */
+  constructor(useDefaultMarket, market, arrayLength, assetIds, useAsCollateral) {
+    super(
+      'AaveV3CollateralSwitch',
+      getAddr('AaveV3CollateralSwitch'),
+      ['uint8','bool', 'uint16[]', 'bool[]','address'],
+      [arrayLength, useDefaultMarket, assetIds, useAsCollateral, market],
+    );
+  }
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // arrayLength
+    encodedInput = encodedInput.concat(this.numberToBytes1(this.args[0]));
+    // useDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[1]));
+    const arrayLength = this.args[0];
+    for (let i = 0; i < arrayLength; i++){
+      // assetIds[i]
+      encodedInput = encodedInput.concat(this.numberToBytes2(this.args[2][i]));
+      // useAsCollateral[i]
+      encodedInput = encodedInput.concat(this.boolToBytes1(this.args[3][i]));
+    }
+    if (!this.args[1]){
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[4]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3CollateralSwitchAction;

package/src/actions/aaveV3/AaveV3PaybackAction.js

@@ -0,0 +1,68 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAssetInfoByAddress } = require("@defisaver/tokens");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3PaybackAction - Payback debt on Aave using underlying token
+ */
+class AaveV3PaybackAction extends ActionWithL2 {
+  /**
+   * @param useOnDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param market {EthAddress} Address provider for specific market
+   * @param amount {string} Amount of tokens to be payed back
+   * @param from {EthAddress} Tokens will be supplied from this address
+   * @param rateMode {number} Type of borrow debt [Stable: 1, Variable: 2]
+   * @param tokenAddr {EthAddress}
+   * @param assetId {number} The id of the underlying asset to be repaid
+   * @param useOnBehalf {boolean} use on behalf param or default to proxy
+   * @param onBehalf {EthAddress} For what user we are paying back the debt, defaults to proxy
+   */
+  constructor(useOnDefaultMarket, market, amount, from, rateMode, tokenAddr, assetId, useOnBehalf , onBehalf = getAddr('Empty')) {
+    super('AaveV3Payback', getAddr('AaveV3Payback'),
+    ['uint256','address','uint8','uint16', 'bool', 'bool','address','address'],
+    [amount, from, rateMode, assetId, useOnDefaultMarket, useOnBehalf, market, onBehalf]
+    );
+
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[6],
+      this.args[7],
+    ];
+    this.tokenForApproval = tokenAddr;
+  }
+
+  async getAssetsToApprove() {
+    const asset = getAssetInfoByAddress(this.tokenForApproval);
+    if (asset.symbol !== 'ETH') return [{asset: this.tokenForApproval, owner: this.args[3]}];
+    return [];
+  }
+
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // amount
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[0]));
+    // from
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[1]));
+    // rateMode
+    encodedInput = encodedInput.concat(this.numberToBytes1(this.args[2]));
+    // assetId
+    encodedInput = encodedInput.concat(this.numberToBytes2(this.args[3]));
+    // useDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[4]));
+    // useOnBehalf
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[5]));
+    if (!this.args[4]) {
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[6]));
+    }
+    if (this.args[5]) {
+      // onBehalf
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[7]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3PaybackAction;

package/src/actions/aaveV3/AaveV3SetEModeAction.js

@@ -0,0 +1,40 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3SetEModeAction - Set EMode for the proxy AaveV3 position
+ */
+class AaveV3SetEModeAction extends ActionWithL2 {
+  /**
+   * @param categoryId {EthAddress} ID of the category emode
+   * @param useOnDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param market {EthAddress} Address provider for specific market
+   */
+  constructor(categoryId, useOnDefaultMarket, market) {
+    super('AaveV3SetEMode', getAddr('AaveV3SetEMode'),
+    ['uint8', 'bool', 'address'],
+    [categoryId, useOnDefaultMarket, market]
+    );
+
+    this.mappableArgs = [
+      this.args[2],
+    ];
+  }
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // categoryId
+    encodedInput = encodedInput.concat(this.numberToBytes1(this.args[0]));
+    // useOnDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[1]));
+    if (!this.args[1]){
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[2]));
+    }
+
+    return encodedInput;
+  }
+
+}
+
+module.exports = AaveV3SetEModeAction;

package/src/actions/aaveV3/AaveV3SupplyAction.js

@@ -0,0 +1,69 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAssetInfoByAddress } = require("@defisaver/tokens");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3SupplyAction - Supply token to an aave position on Aave V3
+ */
+class AaveV3SupplyAction extends ActionWithL2 {
+
+  /**
+   * @param amount {string} Amount of tokens to be deposited
+   * @param from {EthAddress} Tokens will be supplied from this address
+   * @param tokenAddress {EthAddress} Address of the token
+   * @param assetId {number} The id of the token to be deposited
+   * @param enableAsColl {boolean} If we need to enable asset as collateral
+   * @param useDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param useOnBehalf {boolean} use on behalf param or default to proxy
+   * @param market {EthAddress} Address provider for specific market
+   * @param [onBehalf] {EthAddress} For what user we are supplying the tokens, defaults to proxy
+   */
+  constructor(amount, from, tokenAddress, assetId, enableAsColl, useDefaultMarket, useOnBehalf ,market, onBehalf = getAddr('Empty')) {
+    super('AaveV3Supply', getAddr('AaveV3Supply'),
+    ['uint256','address','uint16','bool','bool','bool','address','address'],
+    [amount, from, assetId, enableAsColl, useDefaultMarket, useOnBehalf, market, onBehalf]
+    );
+
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[6],
+      this.args[7],
+    ];
+    this.tokenForApproval = tokenAddress;
+  }
+
+  async getAssetsToApprove() {
+    const asset = getAssetInfoByAddress(this.tokenForApproval);
+    if (asset.symbol !== 'ETH') return [{asset: this.tokenForApproval, owner: this.args[2]}];
+    return [];
+  }
+
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // amount
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[0]));
+    // from
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[1]));
+    // assetId
+    encodedInput = encodedInput.concat(this.numberToBytes2(this.args[2]));
+    // enableAsColl
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[3]));
+    // useDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[4]));
+    // useOnBehalf
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[5]));
+    if (!this.args[4]) {
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[6]));
+    }
+    if (this.args[5]) {
+      // onBehalf
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[7]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3SupplyAction;

package/src/actions/aaveV3/AaveV3SwapBorrowRateModeAction.js

@@ -0,0 +1,43 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3SwapBorrowRateModeAction - Swaps proxy positions borrow rate mode between stable and variable.
+ */
+class AaveV3SwapBorrowRateModeAction extends ActionWithL2 {
+  /**
+   * @param rateMode {string} rate mode the user is swapping from.[Stable: 1, Variable: 2]
+   * @param assetId {number} id of the underlying asset in the market
+   * @param useDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param market {EthAddress} Address provider for specific market
+   *
+   */
+  constructor(rateMode, assetId, useDefaultMarket, market) {
+    super('AaveV3SwapBorrowRateMode', getAddr('AaveV3SwapBorrowRateMode'),
+    ['uint256','uint16','bool','address'],
+    [rateMode, assetId, useDefaultMarket, market]
+    );
+
+    this.mappableArgs = [
+      this.args[0][0],
+      this.args[3],
+    ];
+  }
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // rateMode
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[0]));
+    // assetId
+    encodedInput = encodedInput.concat(this.numberToBytes2(this.args[1]))
+    // useOnDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[2]))
+    if (!this.args[2]){
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[3]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3SwapBorrowRateModeAction;

package/src/actions/aaveV3/AaveV3WithdrawAction.js

@@ -0,0 +1,46 @@
+const ActionWithL2 = require("../../ActionWithL2");
+const { getAddr } = require('../../addresses.js');
+
+/**
+ * AaveV3WithdrawAction - Withdraw a previously supplied token from a position in AaveV3
+ */
+class AaveV3WithdrawAction extends ActionWithL2 {
+  /**
+   * @param assetId {number} The id of the token to be deposited
+   * @param useDefaultMarket {boolean} If this is true it defaults to the hardcoded market in contract
+   * @param amount {string} Amount of tokens to be withdrawn -> send type(uint).max for whole amount
+   * @param to {EthAddress} Where the withdrawn tokens will be sent
+   * @param market {EthAddress} Address provider for specific market
+   */
+  constructor(assetId, useDefaultMarket, amount, to, market) {
+    super('AaveV3Withdraw', getAddr('AaveV3Withdraw'),
+    ['uint16','bool','uint256','address','address'],
+    [assetId, useDefaultMarket, amount, to, market]
+    );
+
+    this.mappableArgs = [
+      this.args[2],
+      this.args[3],
+      this.args[4],
+    ];
+  }
+  encodeInputs() {
+    // executeActionDirectL2
+    let encodedInput = "0x2895f3aa";
+    // assetId
+    encodedInput = encodedInput.concat(this.numberToBytes2(this.args[0]));
+    // useOnDefaultMarket
+    encodedInput = encodedInput.concat(this.boolToBytes1(this.args[1]))
+    // amount
+    encodedInput = encodedInput.concat(this.numberToBytes32(this.args[2]));
+    // from
+    encodedInput = encodedInput.concat(this.addressToBytes20(this.args[3]));
+    if (!this.args[1]){
+      // market
+      encodedInput = encodedInput.concat(this.addressToBytes20(this.args[4]));
+    }
+    return encodedInput;
+  }
+}
+
+module.exports = AaveV3WithdrawAction;

package/src/actions/aaveV3/index.js

@@ -0,0 +1,21 @@
+const AaveV3SupplyAction = require('./AaveV3SupplyAction');
+const AaveV3BorrowAction = require('./AaveV3BorrowAction');
+const AaveV3PaybackAction = require('./AaveV3PaybackAction');
+const AaveV3WithdrawAction = require('./AaveV3WithdrawAction');
+const AaveV3SetEModeAction = require('./AaveV3SetEModeAction');
+const AaveV3ATokenPaybackAction = require('./AaveV3ATokenPaybackAction');
+const AaveV3CollateralSwitchAction = require('./AaveV3CollateralSwitchAction');
+const AaveV3ClaimRewardsAction = require('./AaveV3ClaimRewardsAction');
+const AaveV3SwapBorrowRateModeAction = require('./AaveV3SwapBorrowRateModeAction');
+
+module.exports = {
+    AaveV3SupplyAction,
+    AaveV3BorrowAction,
+    AaveV3PaybackAction,
+    AaveV3WithdrawAction,
+    AaveV3SetEModeAction,
+    AaveV3ATokenPaybackAction,
+    AaveV3CollateralSwitchAction,
+    AaveV3ClaimRewardsAction,
+    AaveV3SwapBorrowRateModeAction,
+}

package/src/actions/basic/SellAction.js

@@ -1,13 +1,14 @@
-const Action = require("../../Action");
-const {requireAddress} = require("../../utils/general");
-const {getAssetInfoByAddress} = require("@defisaver/tokens");
+const ActionAbi = require('../../abis/Action.json');
+const AbiCoder = require('web3-eth-abi');
+const ActionWithL2 = require("../../ActionWithL2");
+const { requireAddress } = require("../../utils/general");
+const { getAssetInfoByAddress } = require("@defisaver/tokens");
 const { getAddr } = require('../../addresses.js');
-const Dec = require('decimal.js');
 
 /**
  * Sells token on DeFi Saver exchange aggregator
  */
-class SellAction extends Action {
+class SellAction extends ActionWithL2 {
   /**
    * @param exchangeOrder {Array} Standard DFS Exchange data
    * @param from {string} Order sender
@@ -38,6 +39,11 @@ class SellAction extends Action {
     ];
   }
 
+  encodeInputs() {
+    const executeActionDirectAbi = ActionAbi.find(({ name }) => name === 'executeActionDirect');
+    return AbiCoder.encodeFunctionCall(executeActionDirectAbi, this._encodeForCall());
+  }
+
   async getAssetsToApprove() {
     const asset = getAssetInfoByAddress(this.args[0][0]);
     if (asset.symbol !== 'ETH') return [{asset: this.args[0][0], owner: this.args[1]}];

package/src/actions/basic/SendTokenAction.js

@@ -1,6 +1,5 @@
 const Action = require("../../Action");
 const {requireAddress} = require("../../utils/general");
-const {getAssetInfoByAddress} = require("@defisaver/tokens");
 const { getAddr } = require('../../addresses.js');
 
 /**