@defisaver/sdk 1.0.34 → 1.0.36

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

@@ -0,0 +1,15 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CurveUsdBorrowAction - Action that borrows crvUSD from proxy curveusd position
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdBorrowAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address to - Address that will receive the borrowed crvUSD, will default to proxy
+     * uint256 debtAmount - Amount of crvUSD to borrow
+     */
+    constructor(controllerAddress: EthAddress, to: EthAddress, debtAmount: uint256);
+}

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

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * CurveUsdBorrowAction - Action that borrows crvUSD from proxy curveusd position
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdBorrowAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address to - Address that will receive the borrowed crvUSD, will default to proxy
+     * uint256 debtAmount - Amount of crvUSD to borrow
+     */
+    /// @dev debtAmount must be non-zero
+    /// @dev if debtAmount == uintMax will borrow as much as the collateral will support
+    constructor(controllerAddress, to, debtAmount) {
+        super('CurveUsdBorrow', getAddr('CurveUsdBorrow'), ['address', 'address', 'uint256'], [controllerAddress, to, debtAmount]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+}

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

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CurveUsdCreateAction - Action that creates a curveusd position on behalf of proxy
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdCreateAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address from - Address from which to pull collateral asset, will default to proxy
+     * address to - Address that will receive the borrowed crvUSD, will default to proxy
+     * uint256 collateralAmount - Amount of collateral asset to supply
+     * uint256 debtAmount - Amount of crvUSD to borrow
+     * uint256 nBands - Number of bands in which the collateral will be supplied
+     */
+    constructor(controllerAddress: EthAddress, from: EthAddress, to: EthAddress, collateralAmount: uint256, debtAmount: uint256, nBands: uint256);
+    getAssetsToApprove(): Promise<{
+        owner: any;
+        asset: string;
+    }[]>;
+}

package/esm/src/actions/curveusd/CurveUsdCreateAction.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 { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+import { controllerToAssetMap } from '../../utils/curveusd-utils';
+/**
+ * CurveUsdCreateAction - Action that creates a curveusd position on behalf of proxy
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdCreateAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address from - Address from which to pull collateral asset, will default to proxy
+     * address to - Address that will receive the borrowed crvUSD, will default to proxy
+     * uint256 collateralAmount - Amount of collateral asset to supply
+     * uint256 debtAmount - Amount of crvUSD to borrow
+     * uint256 nBands - Number of bands in which the collateral will be supplied
+     */
+    /// @dev both collateralAmount and debtAmount must be non-zero and can be maxUint
+    constructor(controllerAddress, from, to, collateralAmount, debtAmount, nBands) {
+        requireAddress(to);
+        super('CurveUsdCreate', getAddr('CurveUsdCreate'), ['address', 'address', 'address', 'uint256', 'uint256', 'uint256'], [controllerAddress, from, to, collateralAmount, debtAmount, nBands]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{
+                    owner: this.args[1],
+                    asset: controllerToAssetMap[this.args[0]],
+                }];
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, uint32, 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, gasUsed: uint32, dfsFeeDivider: uint32, useSteth: Boolean);
+}

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, gasUsed, dfsFeeDivider, useSteth) {
+        requireAddress(from);
+        super('CurveUsdLevCreate', getAddr('CurveUsdLevCreate'), ['address', 'uint256', 'uint256', 'uint256', 'uint256', 'address', 'bytes', 'uint32', 'uint32', 'bool'], [controllerAddress, collateralAmount, debtAmount, minAmount, nBands, from, additionData, gasUsed, dfsFeeDivider, useSteth]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+}

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

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, int256 } from '../../types';
+/**
+ * CurveUsdPaybackAction - Action that pays back crvUSD to a curveusd position
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdPaybackAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address from - Address from which to pull crvUSD, will default to proxy
+     * address onBehalfOf - Address for which we are paying back debt, will default to proxy
+     * address to - Address that will receive the crvUSD and collateral asset if close, will default to proxy
+     * uint256 debtAmount - Amount of crvUSD to payback
+     * int256 maxActiveBand - Don't allow active band to be higher than this (to prevent front-running the repay)
+     */
+    constructor(controllerAddress: EthAddress, from: EthAddress, onBehalfOf: EthAddress, to: EthAddress, debtAmount: uint256, maxActiveBand: int256);
+    getAssetsToApprove(): Promise<{
+        owner: any;
+        asset: string;
+    }[]>;
+}

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

@@ -0,0 +1,43 @@
+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';
+/**
+ * CurveUsdPaybackAction - Action that pays back crvUSD to a curveusd position
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdPaybackAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address from - Address from which to pull crvUSD, will default to proxy
+     * address onBehalfOf - Address for which we are paying back debt, will default to proxy
+     * address to - Address that will receive the crvUSD and collateral asset if close, will default to proxy
+     * uint256 debtAmount - Amount of crvUSD to payback
+     * int256 maxActiveBand - Don't allow active band to be higher than this (to prevent front-running the repay)
+     */
+    /// @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('CurveUsdPayback', getAddr('CurveUsdPayback'), ['address', 'address', 'address', 'address', 'uint256', 'int256'], [controllerAddress, from, onBehalfOf, to, debtAmount, maxActiveBand]);
+        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/CurveUsdRepayAction.d.ts

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

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, gasUsed, dfsFeeDivider, useSteth) {
+        super('CurveUsdRepay', getAddr('CurveUsdRepay'), ['address', 'uint256', 'address', 'uint256', 'bytes', 'uint32', 'uint32', 'bool'], [controllerAddress, collAmount, to, minAmount, additionData, gasUsed, dfsFeeDivider, useSteth]);
+        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, uint32, 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, gasUsed: uint32, dfsFeeDivider: uint32, useSteth: Boolean);
+}

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, gasUsed, dfsFeeDivider, useSteth) {
+        requireAddress(to);
+        super('CurveUsdSelfLiquidateWithColl', getAddr('CurveUsdSelfLiquidateWithColl'), ['address', 'uint256', 'uint256', 'uint256', 'uint256', 'address', 'bytes', 'uint32', 'uint32', 'bool'], [controllerAddress, percentage, minCrvUsdExpected, swapAmount, minAmount, to, additionData, gasUsed, dfsFeeDivider, useSteth]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+}

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

@@ -0,0 +1,20 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CurveUsdSupplyAction - Action that supplies collateral to a curveusd position
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdSupplyAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address from - Address from which to pull collateral asset, will default to proxy
+     * address onBehalfOf - Address for which we are supplying, will default to proxy
+     * uint256 collateralAmount - Amount of collateral asset to supply
+     */
+    constructor(controllerAddress: EthAddress, from: EthAddress, onBehalfOf: EthAddress, collateralAmount: uint256);
+    getAssetsToApprove(): Promise<{
+        owner: any;
+        asset: string;
+    }[]>;
+}

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

@@ -0,0 +1,40 @@
+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 { controllerToAssetMap } from '../../utils/curveusd-utils';
+/**
+ * CurveUsdSupplyAction - Action that supplies collateral to a curveusd position
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdSupplyAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address from - Address from which to pull collateral asset, will default to proxy
+     * address onBehalfOf - Address for which we are supplying, will default to proxy
+     * uint256 collateralAmount - Amount of collateral asset to supply
+     */
+    /// @dev collateralAmount must be non-zero, can be maxUint
+    constructor(controllerAddress, from, onBehalfOf, collateralAmount) {
+        super('CurveUsdSupply', getAddr('CurveUsdSupply'), ['address', 'address', 'address', 'uint256'], [controllerAddress, from, onBehalfOf, collateralAmount]);
+        this.mappableArgs = [
+            ...this.args,
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{
+                    owner: this.args[1],
+                    asset: controllerToAssetMap[this.args[0]],
+                }];
+        });
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * CurveUsdWithdrawAction - Action that withdraws collateral from proxy curveusd position
+ *
+ * @category CurveUsd
+ */
+export declare class CurveUsdWithdrawAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address to - Address that will receive the withdrawn collateral, will default to proxy
+     * uint256 collateralAmount - Amount of collateral to withdraw
+     */
+    constructor(controllerAddress: EthAddress, to: EthAddress, collateralAmount: uint256);
+}

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

@@ -0,0 +1,22 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * CurveUsdWithdrawAction - Action that withdraws collateral from proxy curveusd position
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdWithdrawAction extends Action {
+    /**
+     * address controllerAddress - Address of the curveusd market controller
+     * address to - Address that will receive the withdrawn collateral, will default to proxy
+     * uint256 collateralAmount - Amount of collateral to withdraw
+     */
+    /// @dev collateralAmount must be non-zero
+    /// @dev if collateralAmount == uintMax will withdraw as much as the debt will allow
+    constructor(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

@@ -0,0 +1,9 @@
+export * from './CurveUsdCreateAction';
+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

@@ -0,0 +1,9 @@
+export * from './CurveUsdCreateAction';
+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/flashloan/GhoFlashLoanAction.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256, bytes } from '../../types';
+/**
+ * Gets a GHO flashloan from GHO Flash Minter
+ *
+ * @category Flashloans
+ */
+export declare class GhoFlashLoanAction extends Action {
+    /**
+     * @param amount
+     * @param flParamGetterAddr
+     * @param flParamGetterData
+     */
+    constructor(amount: uint256, flParamGetterAddr?: EthAddress, flParamGetterData?: bytes);
+}

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

@@ -0,0 +1,17 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * Gets a GHO flashloan from GHO Flash Minter
+ *
+ * @category Flashloans
+ */
+export class GhoFlashLoanAction extends Action {
+    /**
+     * @param amount
+     * @param flParamGetterAddr
+     * @param flParamGetterData
+     */
+    constructor(amount, flParamGetterAddr = getAddr('Empty'), flParamGetterData = []) {
+        super('FLGho', getAddr('FLGho'), ['address[]', 'uint256[]', 'uint256[]', 'address', 'address', 'bytes', 'bytes'], [[], [amount], [], getAddr('Empty'), flParamGetterAddr, flParamGetterData, []]);
+    }
+}

package/esm/src/actions/flashloan/GhoFlashLoanPaybackAction.d.ts

@@ -0,0 +1,13 @@
+import { SendTokenAction } from '../basic';
+import { uint256 } from '../../types';
+/**
+ * Pays back a flashloan from GHO
+ *
+ * @category Flashloans
+ */
+export declare class GhoFlashLoanPaybackAction extends SendTokenAction {
+    /**
+     * @param loanAmount
+     */
+    constructor(loanAmount: uint256);
+}

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

@@ -0,0 +1,15 @@
+import { SendTokenAction } from '../basic';
+import { getAddr } from '../../addresses';
+/**
+ * Pays back a flashloan from GHO
+ *
+ * @category Flashloans
+ */
+export class GhoFlashLoanPaybackAction extends SendTokenAction {
+    /**
+     * @param loanAmount
+     */
+    constructor(loanAmount) {
+        super(getAddr('GHO'), getAddr('FLGho'), loanAmount);
+    }
+}

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

@@ -15,3 +15,5 @@ export * from './EulerFlashLoanPaybackAction';
 export * from './FLAction';
 export * from './UniV3FlashLoanAction';
 export * from './UniV3FlashLoanPaybackAction';
+export * from './GhoFlashLoanAction';
+export * from './GhoFlashLoanPaybackAction';

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

@@ -15,3 +15,5 @@ export * from './EulerFlashLoanPaybackAction';
 export * from './FLAction';
 export * from './UniV3FlashLoanAction';
 export * from './UniV3FlashLoanPaybackAction';
+export * from './GhoFlashLoanAction';
+export * from './GhoFlashLoanPaybackAction';

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

@@ -23,4 +23,5 @@ import * as chickenBonds from './chickenBonds';
 import * as compoundV3 from './compoundV3';
 import * as morpho from './morpho';
 import * as bprotocol from './bprotocol';
-export { aave, maker, compound, basic, flashloan, uniswap, reflexer, dydx, uniswapV3, checkers, liquity, yearn, lido, insta, balancer, curve, guni, mstable, rari, aaveV3, convex, chickenBonds, compoundV3, morpho, bprotocol, };
+import * as curveusd from './curveusd';
+export { aave, maker, compound, basic, flashloan, uniswap, reflexer, dydx, uniswapV3, checkers, liquity, yearn, lido, insta, balancer, curve, guni, mstable, rari, aaveV3, convex, chickenBonds, compoundV3, morpho, bprotocol, curveusd, };

package/esm/src/actions/index.js

@@ -23,4 +23,5 @@ import * as chickenBonds from './chickenBonds';
 import * as compoundV3 from './compoundV3';
 import * as morpho from './morpho';
 import * as bprotocol from './bprotocol';
-export { aave, maker, compound, basic, flashloan, uniswap, reflexer, dydx, uniswapV3, checkers, liquity, yearn, lido, insta, balancer, curve, guni, mstable, rari, aaveV3, convex, chickenBonds, compoundV3, morpho, bprotocol, };
+import * as curveusd from './curveusd';
+export { aave, maker, compound, basic, flashloan, uniswap, reflexer, dydx, uniswapV3, checkers, liquity, yearn, lido, insta, balancer, curve, guni, mstable, rari, aaveV3, convex, chickenBonds, compoundV3, morpho, bprotocol, curveusd, };

package/esm/src/addresses.d.ts

@@ -74,6 +74,7 @@ export declare const actionAddresses: {
         FLBalancer: string;
         FLAction: string;
         FLUniV3: string;
+        FLGho: string;
         UniSupply: string;
         UniWithdraw: string;
         UniCollectV3: string;
@@ -143,6 +144,16 @@ export declare const actionAddresses: {
         CompV3Supply: string;
         CompV3Transfer: string;
         CompV3Withdraw: string;
+        CurveUsdBorrow: string;
+        CurveUsdCreate: string;
+        CurveUsdPayback: string;
+        CurveUsdSupply: string;
+        CurveUsdWithdraw: string;
+        CurveUsdLevCreate: string;
+        CurveUsdRepay: string;
+        CurveUsdSwapper: string;
+        CurveUsdSelfLiquidate: string;
+        CurveUsdSelfLiquidateWithColl: string;
         AaveV3RatioTrigger?: undefined;
         GasFeeTakerL2?: undefined;
         AaveV3RatioCheck?: undefined;
@@ -228,6 +239,7 @@ export declare const actionAddresses: {
         FLDyDx?: undefined;
         FLMaker?: undefined;
         FLUniV3?: undefined;
+        FLGho?: undefined;
         UniSupply?: undefined;
         UniWithdraw?: undefined;
         DyDxWithdraw?: undefined;
@@ -292,6 +304,16 @@ export declare const actionAddresses: {
         CompV3Supply?: undefined;
         CompV3Transfer?: undefined;
         CompV3Withdraw?: undefined;
+        CurveUsdBorrow?: undefined;
+        CurveUsdCreate?: undefined;
+        CurveUsdPayback?: undefined;
+        CurveUsdSupply?: undefined;
+        CurveUsdWithdraw?: undefined;
+        CurveUsdLevCreate?: undefined;
+        CurveUsdRepay?: undefined;
+        CurveUsdSwapper?: undefined;
+        CurveUsdSelfLiquidate?: undefined;
+        CurveUsdSelfLiquidateWithColl?: undefined;
     } | {
         DFSSell: string;
         WrapEth: string;
@@ -373,6 +395,7 @@ export declare const actionAddresses: {
         FLDyDx?: undefined;
         FLMaker?: undefined;
         FLUniV3?: undefined;
+        FLGho?: undefined;
         UniSupply?: undefined;
         UniWithdraw?: undefined;
         DyDxWithdraw?: undefined;
@@ -437,6 +460,16 @@ export declare const actionAddresses: {
         CompV3Supply?: undefined;
         CompV3Transfer?: undefined;
         CompV3Withdraw?: undefined;
+        CurveUsdBorrow?: undefined;
+        CurveUsdCreate?: undefined;
+        CurveUsdPayback?: undefined;
+        CurveUsdSupply?: undefined;
+        CurveUsdWithdraw?: undefined;
+        CurveUsdLevCreate?: undefined;
+        CurveUsdRepay?: undefined;
+        CurveUsdSwapper?: undefined;
+        CurveUsdSelfLiquidate?: undefined;
+        CurveUsdSelfLiquidateWithColl?: undefined;
         AaveV3RatioTrigger?: undefined;
     };
 };
@@ -455,6 +488,7 @@ export declare const otherAddresses: {
         CrvToken: string;
         CvxToken: string;
         DAI: string;
+        GHO: string;
         LUSD: string;
         BLUSD: string;
         Empty: string;
@@ -479,6 +513,7 @@ export declare const otherAddresses: {
         CrvToken?: undefined;
         CvxToken?: undefined;
         DAI?: undefined;
+        GHO?: undefined;
         LUSD?: undefined;
         BLUSD?: undefined;
     };