@defisaver/sdk 1.0.35 → 1.0.37

package/esm/src/actions/basic/SDaiUnwrapAction.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * SDaiUnwrapAction - Unwrap sDAI to DAI
+ *
+ * @category Spark
+ */
+export declare class SDaiUnwrapAction extends Action {
+    /**
+     * @param amount Amount of token to unwrap
+     * @param from Address we are pulling sDAI from (fallback to proxy)
+     * @param to Address we are sending DAI to (fallback to proxy)
+     */
+    constructor(amount: uint256, from?: EthAddress, to?: EthAddress);
+}

package/esm/src/actions/basic/SDaiUnwrapAction.js

@@ -0,0 +1,24 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { requireAddress } from '../../utils/general';
+/**
+ * SDaiUnwrapAction - Unwrap sDAI to DAI
+ *
+ * @category Spark
+ */
+export class SDaiUnwrapAction extends Action {
+    /**
+     * @param amount Amount of token to unwrap
+     * @param from Address we are pulling sDAI from (fallback to proxy)
+     * @param to Address we are sending DAI to (fallback to proxy)
+     */
+    constructor(amount, from = getAddr('Empty'), to = getAddr('Empty')) {
+        requireAddress(to);
+        super('SDaiUnwrap', getAddr('SDaiUnwrap'), ['uint256', 'address', 'address'], [amount, from, to]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+}

package/esm/src/actions/basic/SDaiWrapAction.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * SDaiWrapAction - Wrap DAI to sDAI
+ *
+ * @category Spark
+ */
+export declare class SDaiWrapAction extends Action {
+    /**
+     * @param amount Amount of token to wrap
+     * @param from Address we are pulling DAI from (fallback to proxy)
+     * @param to Address we are sending sDAI to (fallback to proxy)
+     */
+    constructor(amount: uint256, from?: EthAddress, to?: EthAddress);
+}

package/esm/src/actions/basic/SDaiWrapAction.js

@@ -0,0 +1,24 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { requireAddress } from '../../utils/general';
+/**
+ * SDaiWrapAction - Wrap DAI to sDAI
+ *
+ * @category Spark
+ */
+export class SDaiWrapAction extends Action {
+    /**
+     * @param amount Amount of token to wrap
+     * @param from Address we are pulling DAI from (fallback to proxy)
+     * @param to Address we are sending sDAI to (fallback to proxy)
+     */
+    constructor(amount, from = getAddr('Empty'), to = getAddr('Empty')) {
+        requireAddress(to);
+        super('SDaiWrap', getAddr('SDaiWrap'), ['uint256', 'address', 'address'], [amount, from, to]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+}

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

@@ -16,3 +16,5 @@ export * from './GasFeeActionL2';
 export * from './TransferNFTAction';
 export * from './SendTokensAction';
 export * from './CreateSubAction';
+export * from './SDaiWrapAction';
+export * from './SDaiUnwrapAction';

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

@@ -16,3 +16,5 @@ export * from './GasFeeActionL2';
 export * from './TransferNFTAction';
 export * from './SendTokensAction';
 export * from './CreateSubAction';
+export * from './SDaiWrapAction';
+export * from './SDaiUnwrapAction';

package/esm/src/actions/checkers/SparkRatioCheckAction.d.ts

@@ -0,0 +1,14 @@
+import { Action } from '../../Action';
+import { uint8, uint256 } from '../../types';
+/**
+ * SparkRatioCheckAction - Checks spark ratio for users proxy position and reverts if faulty
+ *
+ * @category Checkers
+ */
+export declare class SparkRatioCheckAction extends Action {
+    /**
+     * @param ratioState If it should lower/higher
+     * @param targetRatio The ratio user want to be at
+     */
+    constructor(ratioState: uint8, targetRatio: uint256);
+}

package/esm/src/actions/checkers/SparkRatioCheckAction.js

@@ -0,0 +1,20 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * SparkRatioCheckAction - Checks spark ratio for users proxy position and reverts if faulty
+ *
+ * @category Checkers
+ */
+export class SparkRatioCheckAction extends Action {
+    /**
+     * @param ratioState If it should lower/higher
+     * @param targetRatio The ratio user want to be at
+     */
+    constructor(ratioState, targetRatio) {
+        super('SparkRatioCheck', getAddr('SparkRatioCheck'), ['uint8', 'uint256'], [ratioState, targetRatio]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+        ];
+    }
+}

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

@@ -2,3 +2,4 @@ export * from './MakerRatioCheckAction';
 export * from './AaveV3RatioCheckAction';
 export * from './CompoundV3RatioCheckAction';
 export * from './LiquityRatioCheckAction';
+export * from './SparkRatioCheckAction';

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

@@ -2,3 +2,4 @@ export * from './MakerRatioCheckAction';
 export * from './AaveV3RatioCheckAction';
 export * from './CompoundV3RatioCheckAction';
 export * from './LiquityRatioCheckAction';
+export * from './SparkRatioCheckAction';

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

@@ -35,14 +35,20 @@ _FLAction_instances = new WeakSet(), _FLAction_handleArgs = function _FLAction_h
     if (specificFLAction.constructor.name === 'BalancerFlashLoanAction') {
         argsToReturn[5] = [2];
     }
-    if (specificFLAction.constructor.name === 'EulerFlashLoanAction') {
+    if (specificFLAction.constructor.name === 'GhoFlashLoanAction') {
         argsToReturn[5] = [3];
     }
     if (specificFLAction.constructor.name === 'MakerFlashLoanAction') {
         argsToReturn[5] = [4];
     }
-    if (specificFLAction.constructor.name === 'AaveV3FlashLoanNoFeeAction') {
+    if (specificFLAction.constructor.name === 'AaveV3FlashLoanAction') {
         argsToReturn[5] = [5];
     }
+    if (specificFLAction.constructor.name === 'UniV3FlashLoanAction') {
+        argsToReturn[5] = [6];
+    }
+    if (specificFLAction.constructor.name === 'SparkFlashLoanAction') {
+        argsToReturn[5] = [7];
+    }
     return argsToReturn;
 };

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

@@ -0,0 +1,18 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint256, bytes } from '../../types';
+/**
+ * Gets a flashloan from Spark with fee enabled
+ *
+ * @category Flashloans
+ */
+export declare class SparkFlashLoanAction extends ActionWithL2 {
+    /**
+     * @param loanAmounts
+     * @param tokens
+     * @param modes
+     * @param loanPayer
+     * @param flParamGetterAddr
+     * @param flParamGetterData
+     */
+    constructor(tokens: Array<EthAddress>, loanAmounts: Array<uint256>, modes: Array<uint256>, loanPayer: EthAddress, flParamGetterAddr?: EthAddress, flParamGetterData?: bytes);
+}