@defisaver/sdk 1.2.0-dev4 → 1.2.1

package/esm/src/actions/merkl/MerklClaimAction.js

@@ -1,21 +1,21 @@
-import { Action } from '../../Action';
-import { getAddr } from '../../addresses';
-/**
- * MerklClaimAction - Claim Merkl rewards
- *
- * @category Merkl
- */
-export class MerklClaimAction extends Action {
-    /**
-     * @param users - Array filled with smart wallet addresses for each claim
-     * @param tokens - Token that is being claimed
-     * @param amounts - Amount that is being claimed
-     * @param proofs - Array of merkle proofs
-     * @param distinctTokens - Distinct tokens that are claimed inside one claim call
-     * @param amountsClaimedPerDistinctToken - Sum of amounts per distinct token being claimed
-     * @param to - Address which will receive claimed tokens
-     */
-    constructor(users, tokens, amounts, proofs, distinctTokens, amountsClaimedPerDistinctToken, to) {
-        super('MerklClaim', getAddr('MerklClaim'), ['address[]', 'address[]', 'uint256[]', 'bytes32[][]', 'address[]', 'uint256[]', 'address'], [users, tokens, amounts, proofs, distinctTokens, amountsClaimedPerDistinctToken, to]);
-    }
-}
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * MerklClaimAction - Claim Merkl rewards
+ *
+ * @category Merkl
+ */
+export class MerklClaimAction extends Action {
+    /**
+     * @param users - Array filled with smart wallet addresses for each claim
+     * @param tokens - Token that is being claimed
+     * @param amounts - Amount that is being claimed
+     * @param proofs - Array of merkle proofs
+     * @param distinctTokens - Distinct tokens that are claimed inside one claim call
+     * @param amountsClaimedPerDistinctToken - Sum of amounts per distinct token being claimed
+     * @param to - Address which will receive claimed tokens
+     */
+    constructor(users, tokens, amounts, proofs, distinctTokens, amountsClaimedPerDistinctToken, to) {
+        super('MerklClaim', getAddr('MerklClaim'), ['address[]', 'address[]', 'uint256[]', 'bytes32[][]', 'address[]', 'uint256[]', 'address'], [users, tokens, amounts, proofs, distinctTokens, amountsClaimedPerDistinctToken, to]);
+    }
+}

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

@@ -1 +1 @@
-export * from './MerklClaimAction';
+export * from './MerklClaimAction';

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

@@ -1 +1 @@
-export * from './MerklClaimAction';
+export * from './MerklClaimAction';

package/esm/src/actions/morpho/MorphoAaveV2BorrowAction.d.ts

@@ -1,16 +1,16 @@
-import { Action } from '../../Action';
-import { EthAddress, uint256 } from '../../types';
-/**
- * MorphoAaveV2BorrowAction - Borrow token from morpho on behalf of proxy
- *
- * @category Morpho
- */
-export declare class MorphoAaveV2BorrowAction extends Action {
-    /**
-     * @param tokenAddr - Address of Token
-     * @param amount - Amount to borrow
-     * @param to - Borrowed tokens will be sent to this address
-     * @param maxGasForMatching - Max gas to spend on p2p matching
-     */
-    constructor(tokenAddr: EthAddress, amount: uint256, to: EthAddress, maxGasForMatching?: uint256);
-}
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * MorphoAaveV2BorrowAction - Borrow token from morpho on behalf of proxy
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV2BorrowAction extends Action {
+    /**
+     * @param tokenAddr - Address of Token
+     * @param amount - Amount to borrow
+     * @param to - Borrowed tokens will be sent to this address
+     * @param maxGasForMatching - Max gas to spend on p2p matching
+     */
+    constructor(tokenAddr: EthAddress, amount: uint256, to: EthAddress, maxGasForMatching?: uint256);
+}

package/esm/src/actions/morpho/MorphoAaveV2BorrowAction.js

@@ -1,23 +1,23 @@
-import { Action } from '../../Action';
-import { getAddr } from '../../addresses';
-/**
- * MorphoAaveV2BorrowAction - Borrow token from morpho on behalf of proxy
- *
- * @category Morpho
- */
-export class MorphoAaveV2BorrowAction extends Action {
-    /**
-     * @param tokenAddr - Address of Token
-     * @param amount - Amount to borrow
-     * @param to - Borrowed tokens will be sent to this address
-     * @param maxGasForMatching - Max gas to spend on p2p matching
-     */
-    constructor(tokenAddr, amount, to, maxGasForMatching = '0') {
-        super('MorphoAaveV2Borrow', getAddr('MorphoAaveV2Borrow'), ['address', 'uint256', 'address', 'uint256'], [tokenAddr, amount, to, maxGasForMatching]);
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-        ];
-    }
-}
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * MorphoAaveV2BorrowAction - Borrow token from morpho on behalf of proxy
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV2BorrowAction extends Action {
+    /**
+     * @param tokenAddr - Address of Token
+     * @param amount - Amount to borrow
+     * @param to - Borrowed tokens will be sent to this address
+     * @param maxGasForMatching - Max gas to spend on p2p matching
+     */
+    constructor(tokenAddr, amount, to, maxGasForMatching = '0') {
+        super('MorphoAaveV2Borrow', getAddr('MorphoAaveV2Borrow'), ['address', 'uint256', 'address', 'uint256'], [tokenAddr, amount, to, maxGasForMatching]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+}

package/esm/src/actions/morpho/MorphoAaveV2PaybackAction.d.ts

@@ -1,20 +1,20 @@
-import { Action } from '../../Action';
-import { EthAddress, uint256 } from '../../types';
-/**
- * MorphoAaveV2PaybackAction - Supply token to morpho
- *
- * @category Morpho
- */
-export declare class MorphoAaveV2PaybackAction extends Action {
-    /**
-     * @param tokenAddr - Address of Token
-     * @param amount - Token amount
-     * @param from - Tokens will be sent from this address
-     * @param onBehalf - Tokens will be paid back to this address' position (defaults to sender's proxy)
-     */
-    constructor(tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf?: EthAddress);
-    getAssetsToApprove(): Promise<{
-        asset: any;
-        owner: any;
-    }[]>;
-}
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * MorphoAaveV2PaybackAction - Supply token to morpho
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV2PaybackAction extends Action {
+    /**
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be paid back to this address' position (defaults to sender's proxy)
+     */
+    constructor(tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf?: EthAddress);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/morpho/MorphoAaveV2PaybackAction.js

@@ -1,42 +1,42 @@
-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 { Action } from '../../Action';
-import { getAddr } from '../../addresses';
-/**
- * MorphoAaveV2PaybackAction - Supply token to morpho
- *
- * @category Morpho
- */
-export class MorphoAaveV2PaybackAction extends Action {
-    /**
-     * @param tokenAddr - Address of Token
-     * @param amount - Token amount
-     * @param from - Tokens will be sent from this address
-     * @param onBehalf - Tokens will be paid back to this address' position (defaults to sender's proxy)
-     */
-    constructor(tokenAddr, amount, from, onBehalf = getAddr('Empty')) {
-        super('MorphoAaveV2Payback', getAddr('MorphoAaveV2Payback'), ['address', 'uint256', 'address', 'address'], [tokenAddr, amount, from, onBehalf]);
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-            this.args[3],
-        ];
-    }
-    getAssetsToApprove() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const asset = getAssetInfoByAddress(this.args[0]);
-            if (asset.symbol !== 'ETH')
-                return [{ asset: this.args[0], owner: this.args[2] }];
-            return [];
-        });
-    }
-}
+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 { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * MorphoAaveV2PaybackAction - Supply token to morpho
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV2PaybackAction extends Action {
+    /**
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be paid back to this address' position (defaults to sender's proxy)
+     */
+    constructor(tokenAddr, amount, from, onBehalf = getAddr('Empty')) {
+        super('MorphoAaveV2Payback', getAddr('MorphoAaveV2Payback'), ['address', 'uint256', 'address', 'address'], [tokenAddr, amount, from, onBehalf]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.args[0]);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.args[0], owner: this.args[2] }];
+            return [];
+        });
+    }
+}

package/esm/src/actions/morpho/MorphoAaveV2SupplyAction.d.ts

@@ -1,21 +1,21 @@
-import { Action } from '../../Action';
-import { EthAddress, uint256 } from '../../types';
-/**
- * MorphoAaveV2SupplyAction - Supply token to morpho
- *
- * @category Morpho
- */
-export declare class MorphoAaveV2SupplyAction extends Action {
-    /**
-     * @param tokenAddr - Address of tokenAddr
-     * @param amount - Token amount
-     * @param from - Tokens will be sent from this address
-     * @param onBehalf - Tokens will be supplied to this address' position (defaults to sender's proxy)
-     * @param maxGasForMatching - Max gas to spend on p2p matching
-     */
-    constructor(tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf?: EthAddress, maxGasForMatching?: uint256);
-    getAssetsToApprove(): Promise<{
-        asset: any;
-        owner: any;
-    }[]>;
-}
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * MorphoAaveV2SupplyAction - Supply token to morpho
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV2SupplyAction extends Action {
+    /**
+     * @param tokenAddr - Address of tokenAddr
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be supplied to this address' position (defaults to sender's proxy)
+     * @param maxGasForMatching - Max gas to spend on p2p matching
+     */
+    constructor(tokenAddr: EthAddress, amount: uint256, from: EthAddress, onBehalf?: EthAddress, maxGasForMatching?: uint256);
+    getAssetsToApprove(): Promise<{
+        asset: any;
+        owner: any;
+    }[]>;
+}

package/esm/src/actions/morpho/MorphoAaveV2SupplyAction.js

@@ -1,43 +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 { getAssetInfoByAddress } from '@defisaver/tokens';
-import { Action } from '../../Action';
-import { getAddr } from '../../addresses';
-/**
- * MorphoAaveV2SupplyAction - Supply token to morpho
- *
- * @category Morpho
- */
-export class MorphoAaveV2SupplyAction extends Action {
-    /**
-     * @param tokenAddr - Address of tokenAddr
-     * @param amount - Token amount
-     * @param from - Tokens will be sent from this address
-     * @param onBehalf - Tokens will be supplied to this address' position (defaults to sender's proxy)
-     * @param maxGasForMatching - Max gas to spend on p2p matching
-     */
-    constructor(tokenAddr, amount, from, onBehalf = getAddr('Empty'), maxGasForMatching = '0') {
-        super('MorphoAaveV2Supply', getAddr('MorphoAaveV2Supply'), ['address', 'uint256', 'address', 'address', 'uint256'], [tokenAddr, amount, from, onBehalf, maxGasForMatching]);
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-            this.args[3],
-        ];
-    }
-    getAssetsToApprove() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const asset = getAssetInfoByAddress(this.args[0]);
-            if (asset.symbol !== 'ETH')
-                return [{ asset: this.args[0], owner: this.args[2] }];
-            return [];
-        });
-    }
-}
+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 { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * MorphoAaveV2SupplyAction - Supply token to morpho
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV2SupplyAction extends Action {
+    /**
+     * @param tokenAddr - Address of tokenAddr
+     * @param amount - Token amount
+     * @param from - Tokens will be sent from this address
+     * @param onBehalf - Tokens will be supplied to this address' position (defaults to sender's proxy)
+     * @param maxGasForMatching - Max gas to spend on p2p matching
+     */
+    constructor(tokenAddr, amount, from, onBehalf = getAddr('Empty'), maxGasForMatching = '0') {
+        super('MorphoAaveV2Supply', getAddr('MorphoAaveV2Supply'), ['address', 'uint256', 'address', 'address', 'uint256'], [tokenAddr, amount, from, onBehalf, maxGasForMatching]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+        ];
+    }
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asset = getAssetInfoByAddress(this.args[0]);
+            if (asset.symbol !== 'ETH')
+                return [{ asset: this.args[0], owner: this.args[2] }];
+            return [];
+        });
+    }
+}

package/esm/src/actions/morpho/MorphoAaveV2WithdrawAction.d.ts

@@ -1,15 +1,15 @@
-import { Action } from '../../Action';
-import { EthAddress, uint256 } from '../../types';
-/**
- * MorphoAaveV2WithdrawAction - Withdraw token from morpho
- *
- * @category Morpho
- */
-export declare class MorphoAaveV2WithdrawAction extends Action {
-    /**
-     * @param tokenAddr - Address of Token
-     * @param amount - Token amount
-     * @param to - Tokens will be withdrawn to this address
-     */
-    constructor(tokenAddr: EthAddress, amount: uint256, to: EthAddress);
-}
+import { Action } from '../../Action';
+import { EthAddress, uint256 } from '../../types';
+/**
+ * MorphoAaveV2WithdrawAction - Withdraw token from morpho
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV2WithdrawAction extends Action {
+    /**
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param to - Tokens will be withdrawn to this address
+     */
+    constructor(tokenAddr: EthAddress, amount: uint256, to: EthAddress);
+}

package/esm/src/actions/morpho/MorphoAaveV2WithdrawAction.js

@@ -1,22 +1,22 @@
-import { Action } from '../../Action';
-import { getAddr } from '../../addresses';
-/**
- * MorphoAaveV2WithdrawAction - Withdraw token from morpho
- *
- * @category Morpho
- */
-export class MorphoAaveV2WithdrawAction extends Action {
-    /**
-     * @param tokenAddr - Address of Token
-     * @param amount - Token amount
-     * @param to - Tokens will be withdrawn to this address
-     */
-    constructor(tokenAddr, amount, to) {
-        super('MorphoAaveV2Withdraw', getAddr('MorphoAaveV2Withdraw'), ['address', 'uint256', 'address'], [tokenAddr, amount, to]);
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-        ];
-    }
-}
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * MorphoAaveV2WithdrawAction - Withdraw token from morpho
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV2WithdrawAction extends Action {
+    /**
+     * @param tokenAddr - Address of Token
+     * @param amount - Token amount
+     * @param to - Tokens will be withdrawn to this address
+     */
+    constructor(tokenAddr, amount, to) {
+        super('MorphoAaveV2Withdraw', getAddr('MorphoAaveV2Withdraw'), ['address', 'uint256', 'address'], [tokenAddr, amount, to]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+        ];
+    }
+}

package/esm/src/actions/morpho/MorphoClaimAction.d.ts

@@ -1,15 +1,15 @@
-import { Action } from '../../Action';
-import { EthAddress, uint256, bytes32 } from '../../types';
-/**
- * MorphoClaimAction - Claim Morpho rewards
- *
- * @category Morpho
- */
-export declare class MorphoClaimAction extends Action {
-    /**
-     * @param onBehalfOf - Address for which to claim
-     * @param claimable - Claimable amount
-     * @param proof - Merkle proof of claim
-     */
-    constructor(onBehalfOf: EthAddress, claimable: uint256, proof: Array<bytes32>);
-}
+import { Action } from '../../Action';
+import { EthAddress, uint256, bytes32 } from '../../types';
+/**
+ * MorphoClaimAction - Claim Morpho rewards
+ *
+ * @category Morpho
+ */
+export declare class MorphoClaimAction extends Action {
+    /**
+     * @param onBehalfOf - Address for which to claim
+     * @param claimable - Claimable amount
+     * @param proof - Merkle proof of claim
+     */
+    constructor(onBehalfOf: EthAddress, claimable: uint256, proof: Array<bytes32>);
+}

package/esm/src/actions/morpho/MorphoClaimAction.js

@@ -1,20 +1,20 @@
-import { Action } from '../../Action';
-import { getAddr } from '../../addresses';
-/**
- * MorphoClaimAction - Claim Morpho rewards
- *
- * @category Morpho
- */
-export class MorphoClaimAction extends Action {
-    /**
-     * @param onBehalfOf - Address for which to claim
-     * @param claimable - Claimable amount
-     * @param proof - Merkle proof of claim
-     */
-    constructor(onBehalfOf, claimable, proof) {
-        super('MorphoClaim', getAddr('MorphoClaim'), ['address', 'uint256', 'bytes32[]'], [onBehalfOf, claimable, proof]);
-        this.mappableArgs = [
-            this.args[0],
-        ];
-    }
-}
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+/**
+ * MorphoClaimAction - Claim Morpho rewards
+ *
+ * @category Morpho
+ */
+export class MorphoClaimAction extends Action {
+    /**
+     * @param onBehalfOf - Address for which to claim
+     * @param claimable - Claimable amount
+     * @param proof - Merkle proof of claim
+     */
+    constructor(onBehalfOf, claimable, proof) {
+        super('MorphoClaim', getAddr('MorphoClaim'), ['address', 'uint256', 'bytes32[]'], [onBehalfOf, claimable, proof]);
+        this.mappableArgs = [
+            this.args[0],
+        ];
+    }
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3BorrowAction.d.ts

@@ -1,18 +1,18 @@
-import { Action } from '../../../Action';
-import { EthAddress, uint256 } from '../../../types';
-/**
- * MorphoAaveV3BorrowAction - Borrow token from Morpho AaveV3
- *
- * @category Morpho
- */
-export declare class MorphoAaveV3BorrowAction extends Action {
-    /**
-       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
-       * @param tokenAddr - Address of tokenAddr (underlying)
-       * @param amount - Token amount
-       * @param to - The address we are sending the borrowed tokens to
-       * @param onBehalf - For what user we are borrowing the tokens, defaults to proxy
-       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
-       */
-    constructor(emodeId: uint256, tokenAddr: EthAddress, amount: uint256, to: EthAddress, onBehalf?: EthAddress, maxIterations?: uint256);
-}
+import { Action } from '../../../Action';
+import { EthAddress, uint256 } from '../../../types';
+/**
+ * MorphoAaveV3BorrowAction - Borrow token from Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export declare class MorphoAaveV3BorrowAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param to - The address we are sending the borrowed tokens to
+       * @param onBehalf - For what user we are borrowing the tokens, defaults to proxy
+       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
+       */
+    constructor(emodeId: uint256, tokenAddr: EthAddress, amount: uint256, to: EthAddress, onBehalf?: EthAddress, maxIterations?: uint256);
+}

package/esm/src/actions/morpho/aaveV3/MorphoAaveV3BorrowAction.js

@@ -1,27 +1,27 @@
-import { Action } from '../../../Action';
-import { getAddr } from '../../../addresses';
-/**
- * MorphoAaveV3BorrowAction - Borrow token from Morpho AaveV3
- *
- * @category Morpho
- */
-export class MorphoAaveV3BorrowAction extends Action {
-    /**
-       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
-       * @param tokenAddr - Address of tokenAddr (underlying)
-       * @param amount - Token amount
-       * @param to - The address we are sending the borrowed tokens to
-       * @param onBehalf - For what user we are borrowing the tokens, defaults to proxy
-       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
-       */
-    constructor(emodeId, tokenAddr, amount, to, onBehalf = getAddr('Empty'), maxIterations = '4') {
-        super('MorphoAaveV3Borrow', getAddr('MorphoAaveV3Borrow'), ['uint256', 'address', 'uint256', 'address', 'address', 'uint256'], [emodeId, tokenAddr, amount, to, onBehalf, maxIterations]);
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-            this.args[3],
-            this.args[4],
-        ];
-    }
-}
+import { Action } from '../../../Action';
+import { getAddr } from '../../../addresses';
+/**
+ * MorphoAaveV3BorrowAction - Borrow token from Morpho AaveV3
+ *
+ * @category Morpho
+ */
+export class MorphoAaveV3BorrowAction extends Action {
+    /**
+       * @param emodeId Type of emode we are entering in, each one is different deployment on Morpho
+       * @param tokenAddr - Address of tokenAddr (underlying)
+       * @param amount - Token amount
+       * @param to - The address we are sending the borrowed tokens to
+       * @param onBehalf - For what user we are borrowing the tokens, defaults to proxy
+       * @param maxIterations - Max number of iterations for p2p matching, 0 will use default num of iterations
+       */
+    constructor(emodeId, tokenAddr, amount, to, onBehalf = getAddr('Empty'), maxIterations = '4') {
+        super('MorphoAaveV3Borrow', getAddr('MorphoAaveV3Borrow'), ['uint256', 'address', 'uint256', 'address', 'address', 'uint256'], [emodeId, tokenAddr, amount, to, onBehalf, maxIterations]);
+        this.mappableArgs = [
+            this.args[0],
+            this.args[1],
+            this.args[2],
+            this.args[3],
+            this.args[4],
+        ];
+    }
+}