@defisaver/sdk 1.2.9-dev-morpho → 1.2.9-dev-ether-fi

package/src/actions/etherfi/EtherFiUnwrapAction.ts

@@ -0,0 +1,31 @@
+import { getAssetInfo } from '@defisaver/tokens';
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { EthAddress, uint256 } from '../../types';
+import { requireAddress } from '../../utils/general';
+
+/**
+ * EtherFiUnwrapAction - Unwrap weETH and receive eETH
+ *
+ * @category EtherFi
+ */
+export class EtherFiUnwrapAction extends Action {
+  /**
+   * @param amount - amount of weETH to pull
+   * @param from - address from which to pull weETH from
+   * @param to - address where received eETH will be sent to
+   */
+  constructor(amount:uint256, from:EthAddress, to:EthAddress) {
+    requireAddress(to);
+    super('EtherFiUnwrap', getAddr('EtherFiUnwrap'), ['uint256', 'address', 'address'], [amount, from, to]);
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+    ];
+  }
+
+  async getAssetsToApprove() {
+    return [{ asset: getAssetInfo('weETH').address, owner: this.args[1] }];
+  }
+}

package/src/actions/etherfi/EtherFiWrapAction.ts

@@ -0,0 +1,36 @@
+import { getAssetInfo } from '@defisaver/tokens';
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { EthAddress, uint256 } from '../../types';
+import { requireAddress } from '../../utils/general';
+
+/**
+ * EtherFiWrapAction -  Wraps eETH into Wrapped eETH (weETH)
+ *
+ * @category EtherFi
+ */
+export class EtherFiWrapAction extends Action {
+  /**
+   * @param amount - amount of eETH to pull
+   * @param from - address from which to pull eETH from
+   * @param to - address where received weETH will be sent to
+   */
+  constructor(amount:uint256, from:EthAddress, to:EthAddress) {
+    requireAddress(to);
+    super(
+      'EtherFiWrap',
+      getAddr('EtherFiWrap'),
+      ['uint256', 'address', 'address'],
+      [amount, from, to],
+    );
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+    ];
+  }
+
+  async getAssetsToApprove() {
+    return [{ asset: getAssetInfo('eETH').address, owner: this.args[1] }];
+  }
+}

package/src/actions/etherfi/index.ts

@@ -0,0 +1,3 @@
+export * from './EtherFiStakeAction';
+export * from './EtherFiWrapAction';
+export * from './EtherFiUnwrapAction';

package/src/actions/index.ts

@@ -32,6 +32,7 @@ import * as merkl from './merkl';
 import * as eulerV2 from './eulerV2';
 import * as sky from './sky';
 import * as stkgho from './stkgho';
+import * as etherfi from './etherfi';
 
 export {
   aave,
@@ -68,4 +69,5 @@ export {
   eulerV2,
   sky,
   stkgho,
+  etherfi,
 };

package/src/actions/morpho-blue/index.ts

@@ -5,5 +5,4 @@ export * from './MorphoBluePaybackAction';
 export * from './MorphoBlueWithdrawCollateralAction';
 export * from './MorphoBlueWithdrawAction';
 export * from './MorphoBlueSetAuthAction';
-export * from './MorphoBlueSetAuthWithSigAction';
-export * from './MorphoTokenWrapAction';
+export * from './MorphoBlueSetAuthWithSigAction';

package/src/addresses.ts

@@ -89,7 +89,7 @@ export const actionAddresses = {
     LSVBorrow: '0x7dFB434527Fdb39854156cDBa9bF4799E36E7e82',
     LSVSupply: '0x984c00DC098c98bed1CDfe2Ed786Fe1443da6671',
     LSVPayback: '0x10749CE97583dBcEb54a083386CC8438C4e0FE65',
-    LSVSell: '0x0c1bb9A39d4A0EF4215Ade19Ce4F954E8419Dfd7',
+    LSVSell: '0x10B748Dc504C2515Bb6A9e23CB2F686090b6c584',
 
     // morpho aave v2
     MorphoAaveV2Borrow: '0xa85C3E41Bf9F75a381927e1Aa9b00f77C4631109',
@@ -271,7 +271,6 @@ export const actionAddresses = {
     MorphoBluePayback: '0x9f437E5F705E02d77adC2e72C34926978776b085',
     MorphoBlueSetAuth: '0xf30935e20c6357c7bcecd5e58ad6de26d54b9f64',
     MorphoBlueSetAuthWithSig: '0xE2d5fCDBf73BAd24A0FCAf6B2733933A98021808',
-    MorphoTokenWrap: '0x0000000000000000000000000000000000000000',
 
     // llamalend
     LlamaLendCreate: '0x4349be191ea63173eD98b7fC1b0DeC1ef9Bc6c11',
@@ -295,6 +294,11 @@ export const actionAddresses = {
     EulerV2View: '0x8932E46Ecf96b5Fe033F5e27Ab6dC755Cb668967',
 
     MerklClaim: '0xE88036F3F0D7e216D63726356cA2bC334e305fe5',
+
+    // etherFi
+    EtherFiStake: '0x8D9cDA62DC7Bf75f687c6C8729ABB51ac82E20d5',
+    EtherFiWrap: '0x2b10B000292745099Deb15304A247c0816bd8b73',
+    EtherFiUnwrap: '0xDd5F7bf1009Edc3EE55AfcD70D417968bf4647C6',
   },
   [NETWORKS.optimism.chainId]: {
     DFSSell: '0x9f234af5c10c136863a20865ba00b26951ab8269',

package/test/actions/etherFi/EtherFiStakeAction.js

@@ -0,0 +1,66 @@
+const dfs = require('../../../src');
+const {getAssetInfo} = require("@defisaver/tokens");
+const {encodeForDsProxyCall, encodeForRecipe} = require('../../_actionUtils');
+const {assert} = require('chai');
+
+describe('Action: EtherFiStakeAction', () => {
+    let action;
+    const from = '0x80788de454ad3681d357dc7FcB13c72333f684a7';
+    const to = '0x968Cc941aD9074EE687E0423a33E6f2D33d7c327';
+    context('Stake 100 WETH tokens without wrapping', () => {
+        it('constructor', () => {
+            const amount = 100;
+            const shouldWrap = false;
+            action = new dfs.actions.etherfi.EtherFiStakeAction(
+                amount,
+                from,
+                to,
+                shouldWrap,
+            );
+            assert.equal(action.args[0], amount);
+            assert.equal(action.args[1], from);
+            assert.equal(action.args[2], to);
+            assert.equal(action.args[3], shouldWrap);
+        })
+        it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+        it('encodeForRecipe', () => encodeForRecipe(action));
+        it('getEthValue', async () => {
+            const ethValue = await action.getEthValue();
+            assert.equal(ethValue, '0');
+        })
+        it('getAssetsToApprove', async () => {
+            const assetOwnerPairs = await action.getAssetsToApprove();
+            assert.lengthOf(assetOwnerPairs, 1);
+            assert.equal(assetOwnerPairs[0].asset, getAssetInfo('WETH').address);
+            assert.equal(assetOwnerPairs[0].owner, from);
+          })
+    })
+    context('Stake maxUint256 WETH with wrapping', () => {
+        it('constructor', () => {
+            const amount = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+            const shouldWrap = true;
+            action = new dfs.actions.etherfi.EtherFiStakeAction(
+                amount,
+                from,
+                to,
+                shouldWrap,
+            );
+            assert.equal(action.args[0], amount);
+            assert.equal(action.args[1], from);
+            assert.equal(action.args[2], to);
+            assert.equal(action.args[3], shouldWrap);
+        })
+        it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+        it('encodeForRecipe', () => encodeForRecipe(action));
+        it('getEthValue', async () => {
+            const ethValue = await action.getEthValue();
+            assert.equal(ethValue, '0');
+        })
+        it('getAssetsToApprove', async () => {
+            const assetOwnerPairs = await action.getAssetsToApprove();
+            assert.lengthOf(assetOwnerPairs, 1);
+            assert.equal(assetOwnerPairs[0].asset, getAssetInfo('WETH').address);
+            assert.equal(assetOwnerPairs[0].owner, from);
+          })
+    })
+})

package/test/actions/etherFi/EtherFiUnwrapAction.js

@@ -0,0 +1,35 @@
+const dfs = require('../../../src');
+const {getAssetInfo} = require("@defisaver/tokens");
+const {encodeForDsProxyCall, encodeForRecipe} = require('../../_actionUtils');
+const {assert} = require('chai');
+
+describe('Action: EtherFiUnwrap', () => {
+    let action;
+    const from = '0x80788de454ad3681d357dc7FcB13c72333f684a7';
+    const to = '0x968Cc941aD9074EE687E0423a33E6f2D33d7c327';
+    context('Unwrap 100 weETH tokens', () => {
+        it('constructor', () => {
+            const amount = 100;
+            action = new dfs.actions.etherfi.EtherFiUnwrapAction(
+                amount,
+                from,
+                to,
+            );
+            assert.equal(action.args[0], amount);
+            assert.equal(action.args[1], from);
+            assert.equal(action.args[2], to);
+        })
+        it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+        it('encodeForRecipe', () => encodeForRecipe(action));
+        it('getEthValue', async () => {
+            const ethValue = await action.getEthValue();
+            assert.equal(ethValue, '0');
+        })
+        it('getAssetsToApprove', async () => {
+            const assetOwnerPairs = await action.getAssetsToApprove();
+            assert.lengthOf(assetOwnerPairs, 1);
+            assert.equal(assetOwnerPairs[0].asset, getAssetInfo('weETH').address);
+            assert.equal(assetOwnerPairs[0].owner, from);
+          })
+    })
+})

package/test/actions/etherFi/EtherFiWrapAction.js

@@ -0,0 +1,35 @@
+const dfs = require('../../../src');
+const {getAssetInfo} = require("@defisaver/tokens");
+const {encodeForDsProxyCall, encodeForRecipe} = require('../../_actionUtils');
+const {assert} = require('chai');
+
+describe('Action: EtherFiWrap', () => {
+    let action;
+    const from = '0x80788de454ad3681d357dc7FcB13c72333f684a7';
+    const to = '0x968Cc941aD9074EE687E0423a33E6f2D33d7c327';
+    context('Wrap 100 eETH tokens', () => {
+        it('constructor', () => {
+            const amount = 100;
+            action = new dfs.actions.etherfi.EtherFiWrapAction(
+                amount,
+                from,
+                to,
+            );
+            assert.equal(action.args[0], amount);
+            assert.equal(action.args[1], from);
+            assert.equal(action.args[2], to);
+        })
+        it('encodeForDsProxyCall', () => encodeForDsProxyCall(action));
+        it('encodeForRecipe', () => encodeForRecipe(action));
+        it('getEthValue', async () => {
+            const ethValue = await action.getEthValue();
+            assert.equal(ethValue, '0');
+        })
+        it('getAssetsToApprove', async () => {
+            const assetOwnerPairs = await action.getAssetsToApprove();
+            assert.lengthOf(assetOwnerPairs, 1);
+            assert.equal(assetOwnerPairs[0].asset, getAssetInfo('eETH').address);
+            assert.equal(assetOwnerPairs[0].owner, from);
+          })
+    })
+})