@defisaver/sdk 1.0.36 → 1.0.38

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

@@ -0,0 +1,19 @@
+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);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

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

@@ -0,0 +1,39 @@
+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';
+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],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{ asset: getAssetInfo('sDAI').address, owner: this.args[1] }];
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+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);
+    getAssetsToApprove(): Promise<{
+        asset: string;
+        owner: any;
+    }[]>;
+}

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

@@ -0,0 +1,39 @@
+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';
+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],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [{ asset: getAssetInfo('DAI').address, owner: this.args[1] }];
+        });
+    }
+}

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/flashloan/FLAction.js

@@ -35,7 +35,7 @@ _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') {
@@ -44,5 +44,11 @@ _FLAction_instances = new WeakSet(), _FLAction_handleArgs = function _FLAction_h
     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);
+}

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

@@ -0,0 +1,20 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+/**
+ * Gets a flashloan from Spark with fee enabled
+ *
+ * @category Flashloans
+ */
+export class SparkFlashLoanAction extends ActionWithL2 {
+    /**
+     * @param loanAmounts
+     * @param tokens
+     * @param modes
+     * @param loanPayer
+     * @param flParamGetterAddr
+     * @param flParamGetterData
+     */
+    constructor(tokens, loanAmounts, modes, loanPayer, flParamGetterAddr = getAddr('Empty'), flParamGetterData = []) {
+        super('FLSpark', getAddr('FLSpark'), ['address[]', 'uint256[]', 'uint256[]', 'address', 'address', 'bytes', 'bytes'], [tokens, loanAmounts, modes, loanPayer, flParamGetterAddr, flParamGetterData, []]);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { SendTokenAction } from '../basic';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * Pays back a single flashloan from Spark with fee enabled
+ *
+ * @category Flashloans
+ */
+export declare class SparkFlashLoanPaybackAction extends SendTokenAction {
+    /**
+     * @param loanAmount
+     * @param tokenAddr
+     */
+    constructor(loanAmount: uint256, tokenAddr: EthAddress);
+}

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

@@ -0,0 +1,16 @@
+import { SendTokenAction } from '../basic';
+import { getAddr } from '../../addresses';
+/**
+ * Pays back a single flashloan from Spark with fee enabled
+ *
+ * @category Flashloans
+ */
+export class SparkFlashLoanPaybackAction extends SendTokenAction {
+    /**
+     * @param loanAmount
+     * @param tokenAddr
+     */
+    constructor(loanAmount, tokenAddr) {
+        super(tokenAddr, getAddr('FLSpark'), loanAmount);
+    }
+}

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

@@ -6,6 +6,8 @@ export * from './AaveV3FlashLoanAction';
 export * from './AaveV3FlashLoanPaybackAction';
 export * from './AaveV3FlashLoanNoFeeAction';
 export * from './AaveV3FlashLoanNoFeePaybackAction';
+export * from './SparkFlashLoanAction';
+export * from './SparkFlashLoanPaybackAction';
 export * from './MakerFlashLoanAction';
 export * from './MakerFlashLoanPaybackAction';
 export * from './BalancerFlashLoanAction';

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

@@ -6,6 +6,8 @@ export * from './AaveV3FlashLoanAction';
 export * from './AaveV3FlashLoanPaybackAction';
 export * from './AaveV3FlashLoanNoFeeAction';
 export * from './AaveV3FlashLoanNoFeePaybackAction';
+export * from './SparkFlashLoanAction';
+export * from './SparkFlashLoanPaybackAction';
 export * from './MakerFlashLoanAction';
 export * from './MakerFlashLoanPaybackAction';
 export * from './BalancerFlashLoanAction';

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

@@ -24,4 +24,5 @@ import * as compoundV3 from './compoundV3';
 import * as morpho from './morpho';
 import * as bprotocol from './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, };
+import * as spark from './spark';
+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, spark, curveusd, };

package/esm/src/actions/index.js

@@ -24,4 +24,5 @@ import * as compoundV3 from './compoundV3';
 import * as morpho from './morpho';
 import * as bprotocol from './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, };
+import * as spark from './spark';
+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, spark, curveusd, };

package/esm/src/actions/spark/SparkBorrowAction.d.ts

@@ -0,0 +1,21 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint8, uint16, uint256 } from '../../types';
+/**
+ * SparkBorrowAction - Borrow a token from Spark
+ *
+ * @category Spark
+ */
+export declare class SparkBorrowAction 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/spark/SparkBorrowAction.js

@@ -0,0 +1,59 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+import { requireAddress } from '../../utils/general';
+/**
+ * SparkBorrowAction - Borrow a token from Spark
+ *
+ * @category Spark
+ */
+export class SparkBorrowAction 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('SparkBorrow', getAddr('SparkBorrow'), ['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/spark/SparkClaimRewardsAction.d.ts

@@ -0,0 +1,18 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint8, uint256 } from '../../types';
+/**
+ *  SparkClaimRewardsAction
+ *
+ * @category Spark
+ */
+export declare class SparkClaimRewardsAction 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 Address of rewarded token
+     * @param assets Array of position assets to check earned rewards against
+     */
+    constructor(assetsLength: uint8, amount: uint256, to: EthAddress, reward: EthAddress, assets: Array<EthAddress>);
+    encodeInputs(): string;
+}

package/esm/src/actions/spark/SparkClaimRewardsAction.js

@@ -0,0 +1,40 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+import { requireAddress } from '../../utils/general';
+/**
+ *  SparkClaimRewardsAction
+ *
+ * @category Spark
+ */
+export class SparkClaimRewardsAction 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 Address of rewarded token
+     * @param assets Array of position assets to check earned rewards against
+     */
+    constructor(assetsLength, amount, to, reward, assets) {
+        requireAddress(to);
+        super('SparkClaimRewards', getAddr('SparkClaimRewards'), ['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/spark/SparkCollateralSwitchAction.d.ts

@@ -0,0 +1,18 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint8, uint16 } from '../../types';
+/**
+ *  SparkCollateralSwitchAction - Enable/disable token usage as collateral for Spark position
+ *
+ * @category Spark
+ */
+export declare class SparkCollateralSwitchAction 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 Ids of assets to switch
+     * @param useAsCollateral Array of booleans representing collateral state
+     */
+    constructor(useDefaultMarket: boolean, market: EthAddress, arrayLength: uint8, assetIds: Array<uint16>, useAsCollateral: Array<boolean>);
+    encodeInputs(): string;
+}

package/esm/src/actions/spark/SparkCollateralSwitchAction.js

@@ -0,0 +1,39 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+/**
+ *  SparkCollateralSwitchAction - Enable/disable token usage as collateral for Spark position
+ *
+ * @category Spark
+ */
+export class SparkCollateralSwitchAction 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 Ids of assets to switch
+     * @param useAsCollateral Array of booleans representing collateral state
+     */
+    constructor(useDefaultMarket, market, arrayLength, assetIds, useAsCollateral) {
+        super('SparkCollateralSwitch', getAddr('SparkCollateralSwitch'), ['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/spark/SparkPaybackAction.d.ts

@@ -0,0 +1,27 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint8, uint16, uint256 } from '../../types';
+/**
+ * SparkPaybackAction - Payback debt on Spark using underlying token
+ *
+ * @category Spark
+ */
+export declare class SparkPaybackAction 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/spark/SparkPaybackAction.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';
+/**
+ * SparkPaybackAction - Payback debt on Spark using underlying token
+ *
+ * @category Spark
+ */
+export class SparkPaybackAction 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('SparkPayback', getAddr('SparkPayback'), ['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/spark/SparkSetEModeAction.d.ts

@@ -0,0 +1,16 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { EthAddress, uint8 } from '../../types';
+/**
+ * SparkSetEModeAction - Set EMode for the proxy Spark position
+ *
+ * @category Spark
+ */
+export declare class SparkSetEModeAction 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;
+}