@defisaver/sdk 1.1.11 → 1.1.13

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

@@ -1,77 +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;
-    }
-}
+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

@@ -1,16 +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;
-}
+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

@@ -1,33 +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;
-    }
-}
+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

@@ -1,25 +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;
-}
+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

@@ -1,64 +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;
-    }
-}
+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

@@ -1,27 +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;
-}
+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

@@ -1,77 +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;
-    }
-}
+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;
+    }
+}