@defisaver/sdk 1.0.35 → 1.0.37

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

@@ -23,4 +23,6 @@ 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';
+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

@@ -23,4 +23,6 @@ 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';
+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;
+}

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

@@ -0,0 +1,33 @@
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+/**
+ * SparkSetEModeAction - Set EMode for the proxy Spark position
+ *
+ * @category Spark
+ */
+export 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, market, categoryId) {
+        super('SparkSetEMode', getAddr('SparkSetEMode'), ['uint8', 'bool', 'address'], [categoryId, useOnDefaultMarket, market]);
+        this.mappableArgs = [
+            this.args[2],
+        ];
+    }
+    encodeInputs() {
+        // executeActionDirectL2
+        let encodedInput = '0x2895f3aa';
+        // categoryId
+        encodedInput = encodedInput.concat(this.numberToBytes1(this.args[0]));
+        // useOnDefaultMarket
+        encodedInput = encodedInput.concat(this.boolToBytes1(this.args[1]));
+        if (!this.args[1]) {
+            // market
+            encodedInput = encodedInput.concat(this.addressToBytes20(this.args[2]));
+        }
+        return encodedInput;
+    }
+}

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

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

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

@@ -0,0 +1,64 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+import { ActionWithL2 } from '../../ActionWithL2';
+import { getAddr } from '../../addresses';
+/**
+ * SparkSpTokenPaybackAction - Repay Spark debt using spTokens
+ *
+ * @category Spark
+ */
+export class SparkSpTokenPaybackAction extends ActionWithL2 {
+    /**
+     * @param useDefaultMarket If this is true it defaults to the hardcoded market in contract
+     * @param market Address provider for specific market
+     * @param amount Amount of tokens to be payed back (uint.max for full debt)
+     * @param from Where are we pulling the payback spTokens from
+     * @param rateMode Type of borrow debt [Stable: 1, Variable: 2]
+     * @param spTokenAddr address of the spToken to be pulled
+     * @param assetId The id of the underlying asset to be repaid
+     */
+    constructor(useDefaultMarket, market, amount, from, rateMode, spTokenAddr, assetId) {
+        super('SparkSpTokenPayback', getAddr('SparkSpTokenPayback'), ['uint256', 'address', 'uint8', 'uint16', 'bool', 'address'], [amount, from, rateMode, assetId, useDefaultMarket, market]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[5],
+        ];
+        this.addressForApproval = spTokenAddr;
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.addressForApproval);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.addressForApproval, owner: this.args[1] }];
+            return [];
+        });
+    }
+    encodeInputs() {
+        // executeActionDirectL2
+        let encodedInput = '0x2895f3aa';
+        // amount
+        encodedInput = encodedInput.concat(this.numberToBytes32(this.args[0]));
+        // from
+        encodedInput = encodedInput.concat(this.addressToBytes20(this.args[1]));
+        // rateMode
+        encodedInput = encodedInput.concat(this.numberToBytes1(this.args[2]));
+        // assetId
+        encodedInput = encodedInput.concat(this.numberToBytes2(this.args[3]));
+        // useDefaultMarket
+        encodedInput = encodedInput.concat(this.boolToBytes1(this.args[4]));
+        if (!this.args[4]) {
+            // market
+            encodedInput = encodedInput.concat(this.addressToBytes20(this.args[5]));
+        }
+        return encodedInput;
+    }
+}

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

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

package/esm/src/actions/spark/SparkSupplyAction.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';
+/**
+ * SparkSupplyAction - Supply token to an Spark position
+ *
+ * @category Spark
+ */
+export class SparkSupplyAction 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 deposited
+     * @param from Tokens will be supplied from this address
+     * @param tokenAddress Address of the token
+     * @param assetId The id of the token to be deposited
+     * @param enableAsColl If we need to enable asset as collateral
+     * @param useOnBehalf use on behalf param or default to proxy
+     * @param onBehalf For what user we are supplying the tokens, defaults to proxy
+     */
+    constructor(useDefaultMarket, market, amount, from, tokenAddress, assetId, enableAsColl, useOnBehalf, onBehalf = getAddr('Empty')) {
+        super('SparkSupply', getAddr('SparkSupply'), ['uint256', 'address', 'uint16', 'bool', 'bool', 'bool', 'address', 'address'], [amount, from, assetId, enableAsColl, 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],
+        ];
+        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]));
+        // assetId
+        encodedInput = encodedInput.concat(this.numberToBytes2(this.args[2]));
+        // enableAsColl
+        encodedInput = encodedInput.concat(this.boolToBytes1(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;
+    }
+}