@defisaver/sdk 1.2.12 → 1.2.13-dev1

package/src/actions/curveusd/CurveUsdSelfLiquidateWithCollTransientAction.ts

@@ -0,0 +1,55 @@
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
+import { getAddr } from '../../addresses';
+import {
+  EthAddress,
+  uint256,
+  uint32,
+} from '../../types';
+
+/**
+ *
+ * @category CurveUsd
+ */
+export class CurveUsdSelfLiquidateWithCollTransientAction extends Action {
+  constructor(
+    controllerAddress: EthAddress,
+    percentage: uint256,
+    minCrvUsdExpected: uint256,
+    to: EthAddress,
+    exchangeOrder: Array<any>,
+    sellAllCollateral: boolean,
+    gasUsed: uint32,
+  ) {
+    requireAddress(to);
+    super(
+      'CurveUsdSelfLiquidateWithCollTransient',
+      getAddr('CurveUsdSelfLiquidateWithCollTransient'),
+      [
+        'address',
+        'uint256',
+        'uint256',
+        'address',
+        ['address', 'address', 'uint256', 'uint256', 'uint256', 'uint256', 'address', 'address', 'bytes', ['address', 'address', 'address', 'uint256', 'uint256', 'bytes']],
+        'bool',
+        'uint32',
+      ],
+      [
+        controllerAddress,
+        percentage,
+        minCrvUsdExpected,
+        to,
+        exchangeOrder,
+        sellAllCollateral,
+        gasUsed,
+      ],
+    );
+
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+      this.args[3],
+    ];
+  }
+}

package/src/actions/curveusd/index.ts

@@ -8,4 +8,7 @@ export * from './CurveUsdSelfLiquidateAction';
 export * from './CurveUsdLevCreateAction';
 export * from './CurveUsdSelfLiquidateWithCollAction';
 export * from './CurveUsdAdjustAction';
-export * from './CurveUsdGetDebtAction';
+export * from './CurveUsdGetDebtAction';
+export * from './CurveUsdLevCreateTransientAction';
+export * from './CurveUsdRepayTransientAction';
+export * from './CurveUsdSelfLiquidateWithCollTransientAction';

package/src/actions/etherfi/EtherFiStakeAction.ts

@@ -0,0 +1,38 @@
+import { getAssetInfo } from '@defisaver/tokens';
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { EthAddress, uint256 } from '../../types';
+import { requireAddress } from '../../utils/general';
+
+/**
+ * EtherFiStakeAction - Receives WETH, transforms it to ETH then sends it to EtherFi staking contract receiving eETH in return or weETH if wrapping is enabled
+ *
+ * @category EtherFi
+ */
+export class EtherFiStakeAction extends Action {
+  /**
+   * @param amount - amount of WETH to pull
+   * @param from - address from which to pull WETH from
+   * @param to - address where received eETH will be sent to
+   * @param shouldWrap - true if received eETH should be wrapped to weETH
+   */
+  constructor(amount:uint256, from:EthAddress, to:EthAddress, shouldWrap:boolean) {
+    requireAddress(to);
+    super(
+      'EtherFiStake',
+      getAddr('EtherFiStake'),
+      ['uint256', 'address', 'address', 'bool'],
+      [amount, from, to, shouldWrap],
+    );
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+      this.args[3],
+    ];
+  }
+
+  async getAssetsToApprove() {
+    return [{ asset: getAssetInfo('WETH').address, owner: this.args[1] }];
+  }
+}

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/flashloan/CurveUsdFlashLoanAction.ts

@@ -0,0 +1,27 @@
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { EthAddress, uint256, bytes } from '../../types';
+import { FlashLoanId } from './FlashLoanId';
+
+/**
+ * Gets a crvUSD flashloan from CurveUsd Flash Minter
+ *
+ * @category Flashloans
+ */
+export class CurveUsdFlashLoanAction extends Action implements FlashLoanId {
+  public flashLoanId = 9;
+
+  /**
+   * @param amount
+   * @param flParamGetterAddr
+   * @param flParamGetterData
+   */
+  constructor(amount: uint256, flParamGetterAddr: EthAddress = getAddr('Empty'), flParamGetterData: bytes = []) {
+    super(
+      'FLAction',
+      getAddr('FLAction'),
+      ['address[]', 'uint256[]', 'uint256[]', 'address', 'address', 'bytes', 'bytes'],
+      [[], [amount], [], getAddr('Empty'), flParamGetterAddr, flParamGetterData, []],
+    );
+  }
+}

package/src/actions/flashloan/index.ts

@@ -23,3 +23,4 @@ export * from './GhoFlashLoanPaybackAction';
 export * from './MorphoBlueFlashLoanAction';
 export * from './MorphoBlueFlashLoanPaybackAction';
 export * from './FLPaybackAction';
+export * from './CurveUsdFlashLoanAction';

package/src/actions/index.ts

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

package/src/actions/renzo/RenzoStakeAction.ts

@@ -0,0 +1,33 @@
+import { getAssetInfo } from '@defisaver/tokens';
+import { Action } from '../../Action';
+import { getAddr } from '../../addresses';
+import { EthAddress, uint256 } from '../../types';
+import { requireAddress } from '../../utils/general';
+
+/**
+ * RenzoStakeAction - Supplies ETH (action receives WETH) to Renzo for ETH2 Staking. Receives ezETH in return
+ *
+ * @category Renzo
+ */
+export class RenzoStakeAction extends Action {
+  /**
+   * @param amount - amount of WETH to pull
+   * @param from - address from which to pull WETH from
+   * @param to - address where received ezETH will be sent to
+   */
+  constructor(amount:uint256, from:EthAddress, to:EthAddress) {
+    requireAddress(to);
+    super(
+      'RenzoStake', getAddr('RenzoStake'), ['uint256', 'address', 'address'], [amount, from, to],
+    );
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+    ];
+  }
+
+  async getAssetsToApprove() {
+    return [{ asset: getAssetInfo('WETH').address, owner: this.args[1] }];
+  }
+}

package/src/actions/renzo/index.ts

@@ -0,0 +1 @@
+export * from './RenzoStakeAction';

package/src/addresses.ts

@@ -25,6 +25,7 @@ export const actionAddresses = {
     PermitToken: '0x2654056046ed5E3f673FbcBC99A1BDB77F5c460B',
     StarknetClaim: '0x40069889098cd54d6c1021578000f37b197479cf',
     HandleAuth: '0xfc2e2b37c73d5d43cf5fcbd80a4049b620d60eba',
+    SendTokens: '0x7d05c0ABeF6d91300a237026507c4a2631ddAdEa',
 
     // exchange
     DFSSell: '0x901d383c37b30cefad9b6e2bbb0539a40e02c5f4',
@@ -85,11 +86,11 @@ export const actionAddresses = {
     GhoUnstake: '0x3fD02e65B4fb12381946D03815Ff3FF8Ebe2fC63',
 
     // LSV action
-    LSVWithdraw: '0x0A4Ef5ADf759064b546441a50109eCbC2528A455',
+    LSVWithdraw: '0xB0197CF09cc4c9891B0c2fCbE4AD7323154cA8a5',
     LSVBorrow: '0x7dFB434527Fdb39854156cDBa9bF4799E36E7e82',
-    LSVSupply: '0x984c00DC098c98bed1CDfe2Ed786Fe1443da6671',
+    LSVSupply: '0x17a3e39a1aA6d9BA1Ffd80Ae0E388cA064a8D28F',
     LSVPayback: '0x10749CE97583dBcEb54a083386CC8438C4e0FE65',
-    LSVSell: '0x0c1bb9A39d4A0EF4215Ade19Ce4F954E8419Dfd7',
+    LSVSell: '0xE4D93b8d55D7456e85afc0fcF91AC085aF26bbBA',
 
     // morpho aave v2
     MorphoAaveV2Borrow: '0xa85C3E41Bf9F75a381927e1Aa9b00f77C4631109',
@@ -257,11 +258,15 @@ export const actionAddresses = {
     CurveUsdLevCreate: '0xcbd9aFc2b7532b9eeB3A7EC4ea8Bb4320795d9Ad',
     CurveUsdRepay: '0x6F91E8671d17ecEE3D3fb17DcCA87E86B8D83807',
     CurveUsdSwapper: '0xFA8c594b903651F97b27aCADEa83b720cfD7F80b',
+    CurveUsdSwapperTransient: '0xcF0298592b8FCB3823d31Bb257b65afFCAcCb8b6',
     CurveUsdSelfLiquidate: '0xd90d8a4955DfE9D4f45F7f60595313B0925ee1da',
     CurveUsdSelfLiquidateWithColl: '0x7cE305FC2A18c6820a533AD418dC0A549aFeDcAF',
     CurveUsdGetDebt: '0x3Bb41d3f300dA758780fe7696bb4fB93cD7172fB',
     CurveUsdCollRatioTrigger: '0xFCc610809b735BB13E583c5E46595457083D2b0c',
     CurveUsdCollRatioCheck: '0x8c65f37ca216de1625886431249be13ead051388',
+    CurveUsdSelfLiquidateWithCollTransient: '0x9c41eA5D82AF27Fd436Cd4Cf525808313B35f0D1',
+    CurveUsdLevCreateTransient: '0x798eA3B6E1C6210c6594aD5A1dBDA5b6b3347920',
+    CurveUsdRepayTransient: '0xa923a9111377F2f8614E8A1287DbC081e23a29b8',
 
     MorphoBlueSupply: '0x1D0F6027Eeb118dEc06055735eE840E3Fe3E6f9a',
     MorphoBlueSupplyCollateral: '0x1cdAC5D4b207e8DBd308504BbedD5D1BD19D26ac',
@@ -295,6 +300,13 @@ export const actionAddresses = {
     EulerV2View: '0x8932E46Ecf96b5Fe033F5e27Ab6dC755Cb668967',
 
     MerklClaim: '0xE88036F3F0D7e216D63726356cA2bC334e305fe5',
+
+    RenzoStake: '0x17DCF7132E30a0dC3d515C605E7c3D750c61E73c',
+
+    // etherFi
+    EtherFiStake: '0xcadB650B6a60C89f7847Cba555A7eeCC220EA2e8',
+    EtherFiWrap: '0x086464be5c73f66cfbe6b64ec23aa5a86749ef58',
+    EtherFiUnwrap: '0x6Eb09948DDf9332d628d156950b9B1C0c091e8D8',
   },
   [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);
+          })
+    })
+})

package/test/actions/renzo/RenzoStakeAction.js

@@ -0,0 +1,60 @@
+const dfs = require('../../../src');
+const {getAssetInfo} = require("@defisaver/tokens");
+const {encodeForDsProxyCall, encodeForRecipe} = require('../../_actionUtils');
+const {assert} = require('chai');
+
+describe('Action: RenzoStakeAction', () => {
+    let action;
+    const from = '0x80788de454ad3681d357dc7FcB13c72333f684a7';
+    const to = '0x968Cc941aD9074EE687E0423a33E6f2D33d7c327';
+    context('Stake 100 WETH tokens without wrapping', () => {
+        it('constructor', () => {
+            const amount = 100;
+            action = new dfs.actions.renzo.RenzoStakeAction(
+                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('WETH').address);
+            assert.equal(assetOwnerPairs[0].owner, from);
+          })
+    })
+    context('Stake maxUint256 WETH with wrapping', () => {
+        it('constructor', () => {
+            const amount = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+            action = new dfs.actions.renzo.RenzoStakeAction(
+                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('WETH').address);
+            assert.equal(assetOwnerPairs[0].owner, from);
+          })
+    })
+})