@defisaver/sdk 1.0.0 → 1.0.1

package/esm/src/actions/aave/AavePaybackAction.js

@@ -0,0 +1,38 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from "../../Action";
+import { getAddr } from '../../addresses';
+import { getAssetInfoByAddress } from "@defisaver/tokens";
+/**
+ * AavePaybackAction - Payback borrowed tokens from Aave
+ *
+ * @category Aave
+ */
+export class AavePaybackAction extends Action {
+    /**
+     * @param market - Address of market
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param rateMode - Borrow rate mode: Stable: 1, Variable: 2
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be paid back to this address' position (defaults to sender's proxy)
+     */
+    constructor(market, tokenAddr, amount, rateMode, from, onBehalf = getAddr('Empty')) {
+        super('AavePayback', getAddr('AavePayback'), ['address', 'address', 'uint256', 'uint256', 'address', 'address'], [market, tokenAddr, amount, rateMode, from, onBehalf]);
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.args[1]);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.args[1], owner: this.args[4] }];
+            return [];
+        });
+    }
+}

package/esm/src/actions/aave/AaveSupplyAction.d.ts

@@ -0,0 +1,22 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * AaveSupplyAction - Supply token to an aave position
+ *
+ * @category Aave
+ */
+export declare class AaveSupplyAction extends Action {
+    /**
+     * @param market - Address of market
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be supplied to this address' position (defaults to sender's proxy)
+     * @param enableAsColl - If we need to enable asset as collateral
+     */
+    constructor(market: EthAddress, tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf: string | undefined, enableAsColl: boolean);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/aave/AaveSupplyAction.js

@@ -0,0 +1,45 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Action } from "../../Action";
+import { getAddr } from '../../addresses';
+import { getAssetInfoByAddress } from "@defisaver/tokens";
+/**
+ * AaveSupplyAction - Supply token to an aave position
+ *
+ * @category Aave
+ */
+export class AaveSupplyAction extends Action {
+    /**
+     * @param market - Address of market
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be supplied to this address' position (defaults to sender's proxy)
+     * @param enableAsColl - If we need to enable asset as collateral
+     */
+    constructor(market, tokenAddr, amount, from, onBehalf = getAddr('Empty'), enableAsColl) {
+        super('AaveSupply', getAddr('AaveSupply'), ['address', 'address', 'uint256', 'address', 'address', 'bool'], [market, tokenAddr, amount, from, onBehalf, enableAsColl]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.args[1]);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.args[1], owner: this.args[3] }];
+            return [];
+        });
+    }
+}

package/esm/src/actions/aave/AaveWithdrawAction.d.ts

@@ -0,0 +1,16 @@
+import { Action } from "../../Action";
+import { EthAddress, uint256 } from '../../types';
+/**
+ * AaveWithdrawAction - Withdraw token from an aave position
+ *
+ * @category Aave
+ */
+export declare class AaveWithdrawAction extends Action {
+    /**
+     * @param market - Address of market
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param to - Tokens will be withdrawn to this address
+     */
+    constructor(market: EthAddress, tokenAddr: EthAddress, amount: uint256, to: EthAddress);
+}

package/esm/src/actions/aave/AaveWithdrawAction.js

@@ -0,0 +1,20 @@
+import { Action } from "../../Action";
+import { requireAddress } from "../../utils/general";
+import { getAddr } from '../../addresses';
+/**
+ * AaveWithdrawAction - Withdraw token from an aave position
+ *
+ * @category Aave
+ */
+export class AaveWithdrawAction extends Action {
+    /**
+     * @param market - Address of market
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param to - Tokens will be withdrawn to this address
+     */
+    constructor(market, tokenAddr, amount, to) {
+        requireAddress(to);
+        super('AaveWithdraw', getAddr('AaveWithdraw'), ['address', 'address', 'uint256', 'address'], [market, tokenAddr, amount, to]);
+    }
+}

package/esm/src/actions/aave/index.d.ts

@@ -0,0 +1,6 @@
+export * from './AaveBorrowAction';
+export * from './AaveSupplyAction';
+export * from './AavePaybackAction';
+export * from './AaveWithdrawAction';
+export * from './AaveClaimStkAaveAction';
+export * from './AaveCollateralSwitchAction';

package/esm/src/actions/aave/index.js

@@ -0,0 +1,6 @@
+export * from './AaveBorrowAction';
+export * from './AaveSupplyAction';
+export * from './AavePaybackAction';
+export * from './AaveWithdrawAction';
+export * from './AaveClaimStkAaveAction';
+export * from './AaveCollateralSwitchAction';

package/esm/src/actions/aaveV3/AaveV3ATokenPaybackAction.d.ts

@@ -0,0 +1,25 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint8, uint16, uint256 } from '../../types';
+/**
+ * AaveV3ATokenPaybackAction - Repay Aave V3 debt using aTokens
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3ATokenPaybackAction extends ActionWithL2 {
+    addressForApproval: EthAddress;
+    /**
+     * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param amount Amount of tokens to be payed back (uint.max for full debt)
+     * @param from Where are we pulling the payback aTokens from
+     * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+     * @param aTokenAddr address of the aToken to be pulled
+     * @param assetId The id of the underlying asset to be repaid
+     */
+    constructor(useDefaultMarket: boolean, market: EthAddress, amount: uint256, from: EthAddress, rateMode: uint8, aTokenAddr: EthAddress, assetId: uint16);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+    encodeInputs(): string;
+}

package/esm/src/actions/aaveV3/AaveV3ATokenPaybackAction.js

@@ -0,0 +1,64 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ActionWithL2 } from "../../ActionWithL2";
+import { getAssetInfoByAddress } from "@defisaver/tokens";
+import { getAddr } from '../../addresses';
+/**
+ * AaveV3ATokenPaybackAction - Repay Aave V3 debt using aTokens
+ *
+ * @category AaveV3
+ */
+export class AaveV3ATokenPaybackAction extends ActionWithL2 {
+    /**
+     * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param amount Amount of tokens to be payed back (uint.max for full debt)
+     * @param from Where are we pulling the payback aTokens from
+     * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+     * @param aTokenAddr address of the aToken to be pulled
+     * @param assetId 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;
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.addressForApproval);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.addressForApproval, owner: this.args[1] }];
+            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;
+    }
+}

package/esm/src/actions/aaveV3/AaveV3BorrowAction.d.ts

@@ -0,0 +1,21 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint8, uint16, uint256 } from '../../types';
+/**
+ * AaveV3BorrowAction - Borrow a token from AaveV3
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3BorrowAction extends ActionWithL2 {
+    /**
+    * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+    * @param market Address provider for specific market
+    * @param amount Amount of tokens to be borrowed
+    * @param to The address we are sending the borrowed tokens to
+    * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+    * @param assetId The id of the token to be borrowed
+    * @param useOnBehalf use on behalf or default to proxy
+    * @param onBehalf On whose behalf we borrow the tokens, defaults to proxy
+    */
+    constructor(useDefaultMarket: boolean, market: EthAddress, amount: uint256, to: EthAddress, rateMode: uint8, assetId: uint16, useOnBehalf: boolean, onBehalf?: EthAddress);
+    encodeInputs(): string;
+}

package/esm/src/actions/aaveV3/AaveV3BorrowAction.js

@@ -0,0 +1,59 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ * AaveV3BorrowAction - Borrow a token from AaveV3
+ *
+ * @category AaveV3
+ */
+export class AaveV3BorrowAction extends ActionWithL2 {
+    /**
+    * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+    * @param market Address provider for specific market
+    * @param amount Amount of tokens to be borrowed
+    * @param to The address we are sending the borrowed tokens to
+    * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+    * @param assetId The id of the token to be borrowed
+    * @param useOnBehalf use on behalf or default to proxy
+    * @param onBehalf On whose behalf we borrow the tokens, defaults to proxy
+    */
+    constructor(useDefaultMarket, market, amount, to, rateMode, assetId, useOnBehalf, onBehalf = getAddr('Empty')) {
+        requireAddress(to);
+        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[2],
+            this.args[3],
+            this.args[4],
+            this.args[5],
+            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;
+    }
+}

package/esm/src/actions/aaveV3/AaveV3ClaimRewardsAction.d.ts

@@ -0,0 +1,18 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint8, uint256 } from '../../types';
+/**
+ *  AaveV3ClaimRewardsAction
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3ClaimRewardsAction extends ActionWithL2 {
+    /**
+     * @param assetsLength Address provider for specific market
+     * @param amount length of two arrays
+     * @param to Address where claimed tokens will end up on .
+     * @param reward
+     * @param assets
+     */
+    constructor(assetsLength: uint8, amount: uint256, to: EthAddress, reward: EthAddress, assets: Array<EthAddress>);
+    encodeInputs(): string;
+}

package/esm/src/actions/aaveV3/AaveV3ClaimRewardsAction.js

@@ -0,0 +1,40 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { getAddr } from '../../addresses';
+import { requireAddress } from "../../utils/general";
+/**
+ *  AaveV3ClaimRewardsAction
+ *
+ * @category AaveV3
+ */
+export class AaveV3ClaimRewardsAction extends ActionWithL2 {
+    /**
+     * @param assetsLength Address provider for specific market
+     * @param amount length of two arrays
+     * @param to Address where claimed tokens will end up on .
+     * @param reward
+     * @param assets
+     */
+    constructor(assetsLength, amount, to, reward, assets) {
+        requireAddress(to);
+        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;
+    }
+}

package/esm/src/actions/aaveV3/AaveV3CollateralSwitchAction.d.ts

@@ -0,0 +1,18 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint8, uint16 } from '../../types';
+/**
+ *  AaveV3CollateralSwitchAction - Aave enable/disable token usage as collateral for AaveV3 position
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3CollateralSwitchAction extends ActionWithL2 {
+    /**
+     * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param arrayLength length of two arrays
+     * @param assetIds
+     * @param useAsCollateral
+     */
+    constructor(useDefaultMarket: boolean, market: EthAddress, arrayLength: uint8, assetIds: Array<uint16>, useAsCollateral: Array<boolean>);
+    encodeInputs(): string;
+}

package/esm/src/actions/aaveV3/AaveV3CollateralSwitchAction.js

@@ -0,0 +1,39 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { getAddr } from '../../addresses';
+/**
+ *  AaveV3CollateralSwitchAction - Aave enable/disable token usage as collateral for AaveV3 position
+ *
+ * @category AaveV3
+ */
+export class AaveV3CollateralSwitchAction extends ActionWithL2 {
+    /**
+     * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param arrayLength length of two arrays
+     * @param assetIds
+     * @param useAsCollateral
+     */
+    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;
+    }
+}

package/esm/src/actions/aaveV3/AaveV3PaybackAction.d.ts

@@ -0,0 +1,27 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint8, uint16, uint256 } from '../../types';
+/**
+ * AaveV3PaybackAction - Payback debt on Aave using underlying token
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3PaybackAction extends ActionWithL2 {
+    tokenForApproval: EthAddress;
+    /**
+     * @param useOnDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param amount Amount of tokens to be payed back
+     * @param from Tokens will be supplied from this address
+     * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+     * @param tokenAddress Address of token to pay back.
+     * @param assetId The id of the underlying asset to be repaid
+     * @param useOnBehalf  use on behalf param or default to proxy
+     * @param onBehalf For what user we are paying back the debt, defaults to proxy
+     */
+    constructor(useOnDefaultMarket: boolean, market: EthAddress, amount: uint256, from: EthAddress, rateMode: uint8, tokenAddress: EthAddress, assetId: uint16, useOnBehalf: boolean, onBehalf?: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+    encodeInputs(): string;
+}

package/esm/src/actions/aaveV3/AaveV3PaybackAction.js

@@ -0,0 +1,77 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getAssetInfoByAddress } from "@defisaver/tokens";
+import { ActionWithL2 } from "../../ActionWithL2";
+import { getAddr } from '../../addresses';
+/**
+ * AaveV3PaybackAction - Payback debt on Aave using underlying token
+ *
+ * @category AaveV3
+ */
+export class AaveV3PaybackAction extends ActionWithL2 {
+    /**
+     * @param useOnDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param amount Amount of tokens to be payed back
+     * @param from Tokens will be supplied from this address
+     * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+     * @param tokenAddress Address of token to pay back.
+     * @param assetId The id of the underlying asset to be repaid
+     * @param useOnBehalf  use on behalf param or default to proxy
+     * @param onBehalf For what user we are paying back the debt, defaults to proxy
+     */
+    constructor(useOnDefaultMarket, market, amount, from, rateMode, tokenAddress, 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[2],
+            this.args[3],
+            this.args[4],
+            this.args[5],
+            this.args[6],
+            this.args[7],
+        ];
+        this.tokenForApproval = tokenAddress;
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.tokenForApproval);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.tokenForApproval, owner: this.args[1] }];
+            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;
+    }
+}

package/esm/src/actions/aaveV3/AaveV3SetEModeAction.d.ts

@@ -0,0 +1,16 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint8 } from '../../types';
+/**
+ * AaveV3SetEModeAction - Set EMode for the proxy AaveV3 position
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3SetEModeAction extends ActionWithL2 {
+    /**
+     * @param useOnDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param categoryId ID of the category emode
+     */
+    constructor(useOnDefaultMarket: boolean, market: EthAddress, categoryId: uint8);
+    encodeInputs(): string;
+}

package/esm/src/actions/aaveV3/AaveV3SetEModeAction.js

@@ -0,0 +1,33 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { getAddr } from '../../addresses';
+/**
+ * AaveV3SetEModeAction - Set EMode for the proxy AaveV3 position
+ *
+ * @category AaveV3
+ */
+export class AaveV3SetEModeAction extends ActionWithL2 {
+    /**
+     * @param useOnDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param categoryId ID of the category emode
+     */
+    constructor(useOnDefaultMarket, market, categoryId) {
+        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;
+    }
+}

package/esm/src/actions/aaveV3/AaveV3SupplyAction.d.ts

@@ -0,0 +1,27 @@
+import { ActionWithL2 } from "../../ActionWithL2";
+import { EthAddress, uint16, uint256 } from '../../types';
+/**
+ * AaveV3SupplyAction - Supply token to an aave position on Aave V3
+ *
+ * @category AaveV3
+ */
+export declare class AaveV3SupplyAction extends ActionWithL2 {
+    tokenForApproval: EthAddress;
+    /**
+     * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param amount Amount of tokens to be deposited
+     * @param from Tokens will be supplied from this address
+     * @param tokenAddress Address of the token
+     * @param assetId The id of the token to be deposited
+     * @param enableAsColl If we need to enable asset as collateral
+     * @param useOnBehalf use on behalf param or default to proxy
+     * @param onBehalf For what user we are supplying the tokens, defaults to proxy
+     */
+    constructor(useDefaultMarket: boolean, market: EthAddress, amount: uint256, from: EthAddress, tokenAddress: EthAddress, assetId: uint16, enableAsColl: boolean, useOnBehalf: boolean, onBehalf?: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+    encodeInputs(): string;
+}