@defisaver/sdk 1.0.24 → 1.0.26

package/esm/src/Action.js

@@ -108,7 +108,8 @@ export class Action {
         return [AbiCoder.encodeParameter(_paramType, _arg)];
     }
     encodeForL2DsProxyCall() {
-        return this._encodeForCall()[0];
+        const executeActionDirectAbi = (ActionAbi.find(({ name }) => name === 'executeActionDirect'));
+        return AbiCoder.encodeFunctionCall(executeActionDirectAbi, this._encodeForCall());
     }
     encodeForL2Recipe() {
         return this._encodeForCall()[0];

package/esm/src/actions/curveusd/CurveUsdCreateAction.js

@@ -7,12 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { compare } from '@defisaver/tokens/esm/utils';
-import { getAssetInfo } from '@defisaver/tokens';
 import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import { curveusdMarkets } from '../../utils/curveusd-utils';
+import { controllerToAssetMap } from '../../utils/curveusd-utils';
 /**
  * CurveUsdCreateAction - Action that creates a curveusd position on behalf of proxy
  *
@@ -39,7 +37,7 @@ export class CurveUsdCreateAction extends Action {
         return __awaiter(this, void 0, void 0, function* () {
             return [{
                     owner: this.args[1],
-                    asset: getAssetInfo(Object.entries(curveusdMarkets).filter(([, { controllerAddress }]) => compare(controllerAddress, this.args[0]))[0][0]).address,
+                    asset: controllerToAssetMap[this.args[0]],
                 }];
         });
     }

package/esm/src/actions/curveusd/CurveUsdLevCreateAction.d.ts

@@ -0,0 +1,9 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, bytes } from '../../types';
+/**
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdLevCreateAction extends Action {
+    constructor(controllerAddress: EthAddress, collateralAmount: uint256, debtAmount: uint256, minAmount: uint256, nBands: uint256, from: EthAddress, additionData: bytes);
+}

package/esm/src/actions/curveusd/CurveUsdLevCreateAction.js

@@ -0,0 +1,16 @@
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+/**
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdLevCreateAction extends Action {
+    constructor(controllerAddress, collateralAmount, debtAmount, minAmount, nBands, from, additionData) {
+        requireAddress(from);
+        super('CurveUsdLevCreate', getAddr('CurveUsdLevCreate'), ['address', 'uint256', 'uint256', 'uint256', 'uint256', 'address', 'bytes'], [controllerAddress, collateralAmount, debtAmount, minAmount, nBands, from, additionData]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+}

package/esm/src/actions/curveusd/CurveUsdPaybackAction.js

@@ -27,7 +27,7 @@ export class CurveUsdPaybackAction extends Action {
     /// @dev debtAmount must be non-zero
     /// @dev if debtAmount >= debt will repay whole debt and close the position, transfering collateral
     constructor(controllerAddress, from, onBehalfOf, to, debtAmount, maxActiveBand) {
-        super('CurveUsdBorrow', getAddr('CurveUsdBorrow'), ['address', 'address', 'address', 'address', 'uint256', 'int256'], [controllerAddress, from, onBehalfOf, to, debtAmount, maxActiveBand]);
+        super('CurveUsdPayback', getAddr('CurveUsdPayback'), ['address', 'address', 'address', 'address', 'uint256', 'int256'], [controllerAddress, from, onBehalfOf, to, debtAmount, maxActiveBand]);
         this.mappableArgs = [
             ...this.args,
         ];

package/esm/src/actions/curveusd/CurveUsdRepayAction.d.ts

@@ -0,0 +1,9 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, bytes } from '../../types';
+/**
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdRepayAction extends Action {
+    constructor(controllerAddress: EthAddress, collAmount: uint256, to: EthAddress, minAmount: uint256, additionData: bytes);
+}

package/esm/src/actions/curveusd/CurveUsdRepayAction.js

@@ -0,0 +1,14 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdRepayAction extends Action {
+    constructor(controllerAddress, collAmount, to, minAmount, additionData) {
+        super('CurveUsdRepay', getAddr('CurveUsdRepay'), ['address', 'uint256', 'address', 'uint256', 'bytes'], [controllerAddress, collAmount, to, minAmount, additionData]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+}

package/esm/src/actions/curveusd/CurveUsdSelfLiquidateAction.d.ts

@@ -0,0 +1,19 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdSelfLiquidateAction extends Action {
+    /**
+    @param controllerAddress Address of the curveusd market controller
+    @param minCrvUsdExpected Minimum amount of crvUsd as collateral for the user to have
+    @param from Address from which to pull crvUSD if needed
+    @param to Address that will receive the crvUSD and collateral asset
+    */
+    constructor(controllerAddress: EthAddress, minCrvUsdExpected: uint256, from: EthAddress, to: EthAddress);
+    getAssetsToApprove(): Promise<{
+        owner: any;
+        asset: string;
+    }[]>;
+}

package/esm/src/actions/curveusd/CurveUsdSelfLiquidateAction.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 { getAssetInfo } from '@defisaver/tokens';
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdSelfLiquidateAction extends Action {
+    /**
+    @param controllerAddress Address of the curveusd market controller
+    @param minCrvUsdExpected Minimum amount of crvUsd as collateral for the user to have
+    @param from Address from which to pull crvUSD if needed
+    @param to Address that will receive the crvUSD and collateral asset
+    */
+    constructor(controllerAddress, minCrvUsdExpected, from, to) {
+        super('CurveUsdSelfLiquidate', getAddr('CurveUsdSelfLiquidate'), ['address', 'uint256', 'address', 'address'], [controllerAddress, minCrvUsdExpected, from, to]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{
+                    owner: this.args[1],
+                    asset: getAssetInfo('crvUSD').address,
+                }];
+        });
+    }
+}

package/esm/src/actions/curveusd/CurveUsdSelfLiquidateWithCollAction.d.ts

@@ -0,0 +1,9 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, bytes } from '../../types';
+/**
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdSelfLiquidateWithCollAction extends Action {
+    constructor(controllerAddress: EthAddress, percentage: uint256, minCrvUsdExpected: uint256, swapAmount: uint256, minAmount: uint256, to: EthAddress, additionData: bytes);
+}

package/esm/src/actions/curveusd/CurveUsdSelfLiquidateWithCollAction.js

@@ -0,0 +1,16 @@
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+/**
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdSelfLiquidateWithCollAction extends Action {
+    constructor(controllerAddress, percentage, minCrvUsdExpected, swapAmount, minAmount, to, additionData) {
+        requireAddress(to);
+        super('CurveUsdSelfLiquidateWithColl', getAddr('CurveUsdSelfLiquidateWithColl'), ['address', 'uint256', 'uint256', 'uint256', 'uint256', 'address', 'bytes'], [controllerAddress, percentage, minCrvUsdExpected, swapAmount, minAmount, to, additionData]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+}

package/esm/src/actions/curveusd/CurveUsdSupplyAction.js

@@ -7,11 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { compare } from '@defisaver/tokens/esm/utils';
-import { getAssetInfo } from '@defisaver/tokens';
 import { Action } from '../../Action';
 import { getAddr } from '../../addresses';
-import { curveusdMarkets } from '../../utils/curveusd-utils';
+import { controllerToAssetMap } from '../../utils/curveusd-utils';
 /**
  * CurveUsdSupplyAction - Action that supplies collateral to a curveusd position
  *
@@ -35,7 +33,7 @@ export class CurveUsdSupplyAction extends Action {
         return __awaiter(this, void 0, void 0, function* () {
             return [{
                     owner: this.args[1],
-                    asset: getAssetInfo(Object.entries(curveusdMarkets).filter(([, { controllerAddress }]) => compare(controllerAddress, this.args[0]))[0][0]).address,
+                    asset: controllerToAssetMap[this.args[0]],
                 }];
         });
     }

package/esm/src/actions/curveusd/CurveUsdWithdrawAction.js

@@ -14,7 +14,7 @@ export class CurveUsdWithdrawAction extends Action {
     /// @dev collateralAmount must be non-zero
     /// @dev if collateralAmount == uintMax will withdraw as much as the debt will allow
     constructor(controllerAddress, to, collateralAmount) {
-        super('CurveUsdSupply', getAddr('CurveUsdSupply'), ['address', 'address', 'uint256'], [controllerAddress, to, collateralAmount]);
+        super('CurveUsdWithdraw', getAddr('CurveUsdWithdraw'), ['address', 'address', 'uint256'], [controllerAddress, to, collateralAmount]);
         this.mappableArgs = [
             ...this.args,
         ];

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

@@ -3,3 +3,7 @@ export * from './CurveUsdSupplyAction';
 export * from './CurveUsdWithdrawAction';
 export * from './CurveUsdBorrowAction';
 export * from './CurveUsdPaybackAction';
+export * from './CurveUsdRepayAction';
+export * from './CurveUsdSelfLiquidateAction';
+export * from './CurveUsdLevCreateAction';
+export * from './CurveUsdSelfLiquidateWithCollAction';

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

@@ -3,3 +3,7 @@ export * from './CurveUsdSupplyAction';
 export * from './CurveUsdWithdrawAction';
 export * from './CurveUsdBorrowAction';
 export * from './CurveUsdPaybackAction';
+export * from './CurveUsdRepayAction';
+export * from './CurveUsdSelfLiquidateAction';
+export * from './CurveUsdLevCreateAction';
+export * from './CurveUsdSelfLiquidateWithCollAction';

package/esm/src/actions/flashloan/FLAction.js

@@ -41,7 +41,7 @@ _FLAction_instances = new WeakSet(), _FLAction_handleArgs = function _FLAction_h
     if (specificFLAction.constructor.name === 'MakerFlashLoanAction') {
         argsToReturn[5] = [4];
     }
-    if (specificFLAction.constructor.name === 'AaveV3FlashLoanNoFeeAction') {
+    if (specificFLAction.constructor.name === 'AaveV3FlashLoanAction') {
         argsToReturn[5] = [5];
     }
     return argsToReturn;

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3BorrowAction.d.ts

@@ -0,0 +1,18 @@
+import { Action } from '../../../Action';
+import { EthAddress, uint256 } from '../../../types';
+/**
+ * MorphoAaveV3BorrowAction - Borrow token from Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV3BorrowAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param to - The address we are sending the borrowed tokens to
+       * @param onBehalf - For what user we are borrowing the tokens, defaults to proxy
+       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
+       */
+    constructor(emodeId: uint256, tokenAddr: EthAddress, amount: uint256, to: EthAddress, onBehalf?: EthAddress, maxIterations?: uint256);
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3BorrowAction.js

@@ -0,0 +1,27 @@
+import { Action } from '../../../Action';
+import { getAddr } from '../../../addresses';
+/**
+ * MorphoAaveV3BorrowAction - Borrow token from Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV3BorrowAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param to - The address we are sending the borrowed tokens to
+       * @param onBehalf - For what user we are borrowing the tokens, defaults to proxy
+       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
+       */
+    constructor(emodeId, tokenAddr, amount, to, onBehalf = getAddr('Empty'), maxIterations = '4') {
+        super('MorphoAaveV3Borrow', getAddr('MorphoAaveV3Borrow'), ['uint256', 'address', 'uint256', 'address', 'address', 'uint256'], [emodeId, tokenAddr, amount, to, onBehalf, maxIterations]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3PaybackAction.d.ts

@@ -0,0 +1,21 @@
+import { Action } from '../../../Action';
+import { EthAddress, uint256 } from '../../../types';
+/**
+ * MorphoAaveV3PaybackAction - Payback token to Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV3PaybackAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param from - Tokens will be sent from this address
+       * @param onBehalf - For what user we are paying back the debt, defaults to proxy
+       */
+    constructor(emodeId: uint256, tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf?: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3PaybackAction.js

@@ -0,0 +1,44 @@
+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 { Action } from '../../../Action';
+import { getAddr } from '../../../addresses';
+/**
+ * MorphoAaveV3PaybackAction - Payback token to Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV3PaybackAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param from - Tokens will be sent from this address
+       * @param onBehalf - For what user we are paying back the debt, defaults to proxy
+       */
+    constructor(emodeId, tokenAddr, amount, from, onBehalf = getAddr('Empty')) {
+        super('MorphoAaveV3Payback', getAddr('MorphoAaveV3Payback'), ['uint256', 'address', 'uint256', 'address', 'address'], [emodeId, tokenAddr, amount, from, onBehalf]);
+        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/morpho/aaveV3/MorphoAaveV3SupplyAction.d.ts

@@ -0,0 +1,23 @@
+import { Action } from '../../../Action';
+import { EthAddress, uint256 } from '../../../types';
+/**
+ * MorphoAaveV3SupplyAction - Supply token to morpho aaveV3
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV3SupplyAction extends Action {
+    /**
+     * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+     * @param tokenAddr - Address of tokenAddr (underlying)
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - For what user we are paying back the debt, defaults to proxy
+     * @param supplyAsColl Whether to supplyAsCollateral or regular supply
+     * @param maxIterations Max number of iterations for p2p matching, 0 will use default num of iterations
+     */
+    constructor(emodeId: uint256, tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf?: EthAddress, supplyAsColl?: boolean, maxIterations?: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3SupplyAction.js

@@ -0,0 +1,47 @@
+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 { Action } from '../../../Action';
+import { getAddr } from '../../../addresses';
+/**
+ * MorphoAaveV3SupplyAction - Supply token to morpho aaveV3
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV3SupplyAction extends Action {
+    /**
+     * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+     * @param tokenAddr - Address of tokenAddr (underlying)
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - For what user we are paying back the debt, defaults to proxy
+     * @param supplyAsColl Whether to supplyAsCollateral or regular supply
+     * @param maxIterations Max number of iterations for p2p matching, 0 will use default num of iterations
+     */
+    constructor(emodeId, tokenAddr, amount, from, onBehalf = getAddr('Empty'), supplyAsColl = true, maxIterations = '4') {
+        super('MorphoAaveV3Supply', getAddr('MorphoAaveV3Supply'), ['uint256', 'address', 'uint256', 'address', 'address', 'bool', 'uint256'], [emodeId, tokenAddr, amount, from, onBehalf, supplyAsColl, maxIterations]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+            this.args[5],
+        ];
+    }
+    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/morpho/aaveV3/MorphoAaveV3WithdrawAction.d.ts

@@ -0,0 +1,19 @@
+import { Action } from '../../../Action';
+import { EthAddress, uint256 } from '../../../types';
+/**
+ * MorphoAaveV3WithdrawAction - Withdraw token from Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV3WithdrawAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param to - Tokens will be sent to this address
+       * @param onBehalf - For what user we are withdrawing the tokens, defaults to proxy
+       * @param withdrawAsColl - If we want to withdraw from collateral or from pure supply
+       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
+       */
+    constructor(emodeId: uint256, tokenAddr: EthAddress, amount: uint256, to: EthAddress, onBehalf?: EthAddress, withdrawAsColl?: boolean, maxIterations?: uint256);
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3WithdrawAction.js

@@ -0,0 +1,29 @@
+import { Action } from '../../../Action';
+import { getAddr } from '../../../addresses';
+/**
+ * MorphoAaveV3WithdrawAction - Withdraw token from Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV3WithdrawAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param to - Tokens will be sent to this address
+       * @param onBehalf - For what user we are withdrawing the tokens, defaults to proxy
+       * @param withdrawAsColl - If we want to withdraw from collateral or from pure supply
+       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
+       */
+    constructor(emodeId, tokenAddr, amount, to, onBehalf = getAddr('Empty'), withdrawAsColl = true, maxIterations = '4') {
+        super('MorphoAaveV3Withdraw', getAddr('MorphoAaveV3Withdraw'), ['uint256', 'address', 'uint256', 'address', 'address', 'bool', 'uint256'], [emodeId, tokenAddr, amount, to, onBehalf, withdrawAsColl, maxIterations]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+            this.args[5],
+        ];
+    }
+}

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

@@ -3,3 +3,7 @@ export * from './MorphoAaveV2WithdrawAction';
 export * from './MorphoAaveV2BorrowAction';
 export * from './MorphoAaveV2PaybackAction';
 export * from './MorphoClaimAction';
+export * from './aaveV3/MorphoAaveV3SupplyAction';
+export * from './aaveV3/MorphoAaveV3WithdrawAction';
+export * from './aaveV3/MorphoAaveV3BorrowAction';
+export * from './aaveV3/MorphoAaveV3PaybackAction';

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

@@ -3,3 +3,7 @@ export * from './MorphoAaveV2WithdrawAction';
 export * from './MorphoAaveV2BorrowAction';
 export * from './MorphoAaveV2PaybackAction';
 export * from './MorphoClaimAction';
+export * from './aaveV3/MorphoAaveV3SupplyAction';
+export * from './aaveV3/MorphoAaveV3WithdrawAction';
+export * from './aaveV3/MorphoAaveV3BorrowAction';
+export * from './aaveV3/MorphoAaveV3PaybackAction';

package/esm/src/addresses.d.ts

@@ -54,6 +54,10 @@ export declare const actionAddresses: {
         MorphoAaveV2Supply: string;
         MorphoAaveV2Withdraw: string;
         MorphoClaim: string;
+        MorphoAaveV3Borrow: string;
+        MorphoAaveV3Payback: string;
+        MorphoAaveV3Supply: string;
+        MorphoAaveV3Withdraw: string;
         CompBorrow: string;
         CompClaim: string;
         CompPayback: string;
@@ -137,6 +141,12 @@ export declare const actionAddresses: {
         CompV3Supply: string;
         CompV3Transfer: string;
         CompV3Withdraw: string;
+        CurveUsdBorrow: string;
+        CurveUsdCreate: string;
+        CurveUsdPayback: string;
+        CurveUsdSupply: string;
+        CurveUsdWithdraw: string;
+        CurveUsdSelfLiquidate: string;
         AaveV3RatioTrigger?: undefined;
         GasFeeTakerL2?: undefined;
         AaveV3RatioCheck?: undefined;
@@ -206,6 +216,10 @@ export declare const actionAddresses: {
         MorphoAaveV2Supply?: undefined;
         MorphoAaveV2Withdraw?: undefined;
         MorphoClaim?: undefined;
+        MorphoAaveV3Borrow?: undefined;
+        MorphoAaveV3Payback?: undefined;
+        MorphoAaveV3Supply?: undefined;
+        MorphoAaveV3Withdraw?: undefined;
         CompBorrow?: undefined;
         CompClaim?: undefined;
         CompPayback?: undefined;
@@ -280,6 +294,12 @@ export declare const actionAddresses: {
         CompV3Supply?: undefined;
         CompV3Transfer?: undefined;
         CompV3Withdraw?: undefined;
+        CurveUsdBorrow?: undefined;
+        CurveUsdCreate?: undefined;
+        CurveUsdPayback?: undefined;
+        CurveUsdSupply?: undefined;
+        CurveUsdWithdraw?: undefined;
+        CurveUsdSelfLiquidate?: undefined;
     } | {
         DFSSell: string;
         WrapEth: string;
@@ -345,6 +365,10 @@ export declare const actionAddresses: {
         MorphoAaveV2Supply?: undefined;
         MorphoAaveV2Withdraw?: undefined;
         MorphoClaim?: undefined;
+        MorphoAaveV3Borrow?: undefined;
+        MorphoAaveV3Payback?: undefined;
+        MorphoAaveV3Supply?: undefined;
+        MorphoAaveV3Withdraw?: undefined;
         CompBorrow?: undefined;
         CompClaim?: undefined;
         CompPayback?: undefined;
@@ -419,6 +443,12 @@ export declare const actionAddresses: {
         CompV3Supply?: undefined;
         CompV3Transfer?: undefined;
         CompV3Withdraw?: undefined;
+        CurveUsdBorrow?: undefined;
+        CurveUsdCreate?: undefined;
+        CurveUsdPayback?: undefined;
+        CurveUsdSupply?: undefined;
+        CurveUsdWithdraw?: undefined;
+        CurveUsdSelfLiquidate?: undefined;
         AaveV3RatioTrigger?: undefined;
     };
 };

package/esm/src/addresses.js

@@ -62,6 +62,11 @@ export const actionAddresses = {
         MorphoAaveV2Supply: '0x60ED1Cf5Da785AA4FD4A4fF3f8cFc0682d60E0F3',
         MorphoAaveV2Withdraw: '0x29a8b5a8889f465c85b778edccf984e44ad70f12',
         MorphoClaim: '0xa269C841E26EA8Ee1F0350a2E5905F71446998dC',
+        // morpho aave v3
+        MorphoAaveV3Borrow: '0x487719C57b88477F19423aB0652b3E26b96baA7F',
+        MorphoAaveV3Payback: '0x36b8b968c81D97cBfAa642e206b634A6f378d287',
+        MorphoAaveV3Supply: '0x51fA8FBc6F0aDEfe2FBA06104FCA39f5beD69291',
+        MorphoAaveV3Withdraw: '0xdc3e74C4cD577275296ceFE36A3D082223AfF206',
         // compound
         CompBorrow: '0x8495579BF6Ae848f7E59686536F834f1d2CCd79C',
         CompClaim: '0x81F488cF7A0128A9DB5e7207042cCAB1CB0ac902',
@@ -163,6 +168,13 @@ export const actionAddresses = {
         CompV3Supply: '0xaF36Eca43bb26468078B8163fe5Bc1fCFc292095',
         CompV3Transfer: '0xeD7450e9C17146476137b77198DFfB17857906c4',
         CompV3Withdraw: '0x0b0F21EDE32DE4243D9145a899E97FC2366Aec46',
+        // crvUSD
+        CurveUsdBorrow: '0x6493Aa22802B97d2a1E0bF0248135258113D7358',
+        CurveUsdCreate: '0xE934d90FBACBeb3c13Be90061383b419415d5F9B',
+        CurveUsdPayback: '0x667E2Ef4371E3Da4aa3e09Cde18c908B10868C38',
+        CurveUsdSupply: '0x08e50Dc1a22282A003Cff9AC6ef1A687acfe18c2',
+        CurveUsdWithdraw: '0x5Ed2b787D2f76Ff0Ff5c789c9F48b5a8BaeBf56b',
+        CurveUsdSelfLiquidate: '0x47E8235A038BcBD979041E974F02b0A4eAe69fC3',
     },
     [NETWORKS.optimism.chainId]: {
         DFSSell: '0xC6c601fcAa870efd26C624F8c65fbc54cBe533b1',