@defisaver/sdk 1.0.1 → 1.0.2

package/src/actions/curve/CurveDepositAction.ts

@@ -1,18 +1,17 @@
 import { getAssetInfo } from '@defisaver/tokens';
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
 import { poolInfo, makeFlags } from '../../utils/curve-utils';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * @category Curve
  */
 export class CurveDepositAction extends Action {
+  tokensForApproval:Array<EthAddress>;
 
-    tokensForApproval:Array<EthAddress>;
-
-    /**
+  /**
      * @param sender
      * @param receiver
      * @param poolAddr
@@ -20,66 +19,66 @@ export class CurveDepositAction extends Action {
      * @param useUnderlying
      * @param amounts
      */
-    constructor(
-        sender:EthAddress,
-        receiver:EthAddress,
-        poolAddr:EthAddress,
-        minMintAmount:uint256,
-        useUnderlying:boolean,
-        amounts:Array<uint256> = [],
-    ) {
-        requireAddress(sender);
-        requireAddress(receiver);
+  constructor(
+    sender:EthAddress,
+    receiver:EthAddress,
+    poolAddr:EthAddress,
+    minMintAmount:uint256,
+    useUnderlying:boolean,
+    amounts:Array<uint256> = [],
+  ) {
+    requireAddress(sender);
+    requireAddress(receiver);
 
-        let depositTarget;
-        let depositTargetType = 0;
-        let explicitUnderlying = false;
-        let tokensForApproval;
+    let depositTarget;
+    let depositTargetType = 0;
+    let explicitUnderlying = false;
+    let tokensForApproval;
 
-        const pool = poolInfo.find((e) => e.swapAddr.toLowerCase() === poolAddr.toLowerCase())!;
-        if (useUnderlying) {
-            if (pool.depositContract) {
-                depositTarget = pool.depositContract;
-                depositTargetType = pool.zapType + 1;
-            } else {
-                depositTarget = pool.swapAddr;
-                explicitUnderlying = pool.underlyingFlag!;
-                if (!explicitUnderlying) throw Error('pool has no underlying deposit mechanism');
-            }
-            tokensForApproval = pool.underlyingCoins;
-        } else {
-            depositTarget = pool.swapAddr;
-            tokensForApproval = pool.coins;
-        }
+    const pool = poolInfo.find((e) => e.swapAddr.toLowerCase() === poolAddr.toLowerCase())!;
+    if (useUnderlying) {
+      if (pool.depositContract) {
+        depositTarget = pool.depositContract;
+        depositTargetType = pool.zapType + 1;
+      } else {
+        depositTarget = pool.swapAddr;
+        explicitUnderlying = pool.underlyingFlag!;
+        if (!explicitUnderlying) throw Error('pool has no underlying deposit mechanism');
+      }
+      tokensForApproval = pool.underlyingCoins;
+    } else {
+      depositTarget = pool.swapAddr;
+      tokensForApproval = pool.coins;
+    }
 
-        super('CurveDeposit',
-            getAddr('CurveDeposit'),
-            ['address', 'address', 'address', 'uint256', 'uint8', 'uint256[]'],
-            [
-                sender,
-                receiver,
-                depositTarget,
-                minMintAmount,
-                makeFlags(depositTargetType, explicitUnderlying, 0),
-                amounts,
-            ],
-        );
-        this.tokensForApproval = tokensForApproval;
+    super('CurveDeposit',
+      getAddr('CurveDeposit'),
+      ['address', 'address', 'address', 'uint256', 'uint8', 'uint256[]'],
+      [
+        sender,
+        receiver,
+        depositTarget,
+        minMintAmount,
+        makeFlags(depositTargetType, explicitUnderlying, 0),
+        amounts,
+      ],
+    );
+    this.tokensForApproval = tokensForApproval;
 
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-            this.args[3],
-            this.args[4],
-            ...this.args[5],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+      this.args[3],
+      this.args[4],
+      ...this.args[5],
+    ];
+  }
 
-    async getAssetsToApprove() {
-        return this.tokensForApproval.map((e) => Object({
-            asset: e.toLowerCase() !== getAssetInfo('ETH').address.toLowerCase() ? e : getAssetInfo('WETH').address,
-            owner: this.args[0],
-        }));
-    }
+  async getAssetsToApprove() {
+    return this.tokensForApproval.map((e) => Object({
+      asset: e.toLowerCase() !== getAssetInfo('ETH').address.toLowerCase() ? e : getAssetInfo('WETH').address,
+      owner: this.args[0],
+    }));
+  }
 }

package/src/actions/curve/CurveGaugeDepositAction.ts

@@ -1,14 +1,13 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * @category Curve
  */
 export class CurveGaugeDepositAction extends Action {
-
-    /**
+  /**
      *
      * @param gaugeAddr
      * @param lpToken
@@ -16,23 +15,23 @@ export class CurveGaugeDepositAction extends Action {
      * @param onBehalfOf
      * @param amount
      */
-    constructor(gaugeAddr:EthAddress, lpToken:EthAddress, sender:EthAddress, onBehalfOf:EthAddress, amount:uint256) {
-        requireAddress(sender);
-        requireAddress(onBehalfOf);
-        super('CurveGaugeDeposit',
-            getAddr('CurveGaugeDeposit'),
-            ['address', 'address', 'address', 'address', 'uint256'],
-            [gaugeAddr, lpToken, sender, onBehalfOf, amount],
-        );
+  constructor(gaugeAddr:EthAddress, lpToken:EthAddress, sender:EthAddress, onBehalfOf:EthAddress, amount:uint256) {
+    requireAddress(sender);
+    requireAddress(onBehalfOf);
+    super('CurveGaugeDeposit',
+      getAddr('CurveGaugeDeposit'),
+      ['address', 'address', 'address', 'address', 'uint256'],
+      [gaugeAddr, lpToken, sender, onBehalfOf, amount],
+    );
 
-        this.mappableArgs = [
-            this.args[2],
-            this.args[3],
-            this.args[4],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[2],
+      this.args[3],
+      this.args[4],
+    ];
+  }
 
-    async getAssetsToApprove() {
-        return [{ asset: this.args[1], owner: this.args[2] }];
-    }
+  async getAssetsToApprove() {
+    return [{ asset: this.args[1], owner: this.args[2] }];
+  }
 }

package/src/actions/curve/CurveGaugeWithdrawAction.ts

@@ -1,30 +1,29 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * @category Curve
  */
 export class CurveGaugeWithdrawAction extends Action {
-
-    /**
+  /**
      * @param gaugeAddr
      * @param lpToken
      * @param receiver
      * @param amount
      */
-    constructor(gaugeAddr:EthAddress, lpToken:EthAddress, receiver:EthAddress, amount:uint256) {
-        requireAddress(receiver);
-        super('CurveGaugeWithdraw',
-            getAddr('CurveGaugeWithdraw'),
-            ['address', 'address', 'address', 'uint256'],
-            [gaugeAddr, lpToken, receiver, amount],
-        );
+  constructor(gaugeAddr:EthAddress, lpToken:EthAddress, receiver:EthAddress, amount:uint256) {
+    requireAddress(receiver);
+    super('CurveGaugeWithdraw',
+      getAddr('CurveGaugeWithdraw'),
+      ['address', 'address', 'address', 'uint256'],
+      [gaugeAddr, lpToken, receiver, amount],
+    );
 
-        this.mappableArgs = [
-            this.args[2],
-            this.args[3],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[2],
+      this.args[3],
+    ];
+  }
 }

package/src/actions/curve/CurveMintCrvAction.ts

@@ -1,27 +1,26 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress} from '../../types';
+import { EthAddress } from '../../types';
 
 /**
  * @category Curve
  */
 export class CurveMintCrvAction extends Action {
-
-    /**
+  /**
      * @param gaugeAddrs
      * @param receiver
      */
-    constructor(gaugeAddrs:EthAddress[8], receiver:EthAddress) {
-        requireAddress(receiver);
-        super('CurveMintCrv',
-            getAddr('CurveMintCrv'),
-            ['address[8]', 'address'],
-            [gaugeAddrs, receiver],
-        );
+  constructor(gaugeAddrs:EthAddress[8], receiver:EthAddress) {
+    requireAddress(receiver);
+    super('CurveMintCrv',
+      getAddr('CurveMintCrv'),
+      ['address[8]', 'address'],
+      [gaugeAddrs, receiver],
+    );
 
-        this.mappableArgs = [
-            this.args[8],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[8],
+    ];
+  }
 }

package/src/actions/curve/CurveStethPoolDepositAction.ts

@@ -1,41 +1,41 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * CurveStethPoolDepositAction - Deposits tokens into curve steth pool
- * 
+ *
  * @category Curve
  */
 export class CurveStethPoolDepositAction extends Action {
-    /**
-     * @param from 
-     * @param to 
+  /**
+     * @param from
+     * @param to
      * @param amounts
      * @param minMintAmount
      */
-    constructor(
-        from:EthAddress,
-        to:EthAddress,
-        amounts:uint256[2],
-        minMintAmount:uint256,
-    ) {
-        requireAddress(to);
+  constructor(
+    from:EthAddress,
+    to:EthAddress,
+    amounts:uint256[2],
+    minMintAmount:uint256,
+  ) {
+    requireAddress(to);
 
-        super(
-            'CurveStethPoolDeposit',
-            getAddr('CurveStethPoolDeposit'),
-            ['address', 'address', 'uint256[2]', 'uint256'],
-            [from,to,amounts,minMintAmount],
-        );
+    super(
+      'CurveStethPoolDeposit',
+      getAddr('CurveStethPoolDeposit'),
+      ['address', 'address', 'uint256[2]', 'uint256'],
+      [from, to, amounts, minMintAmount],
+    );
 
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2][0],
-            this.args[2][1],
-            this.args[3],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2][0],
+      this.args[2][1],
+      this.args[3],
+    ];
+  }
 }

package/src/actions/curve/CurveStethPoolWithdrawAction.ts

@@ -1,43 +1,43 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * CurveStethPoolWithdrawAction - Withdraws tokens from curve steth pool
- * 
+ *
  * @category Curve
  */
 export class CurveStethPoolWithdrawAction extends Action {
-    /**
+  /**
      * @param from
      * @param to
      * @param amounts
      * @param maxBurnAmount
      * @param returnValue
      */
-    constructor(
-        from:EthAddress,
-        to:EthAddress,
-        amounts:uint256[2],
-        maxBurnAmount:uint256,
-        returnValue:uint256,
-    ) {
-        requireAddress(to);
+  constructor(
+    from:EthAddress,
+    to:EthAddress,
+    amounts:uint256[2],
+    maxBurnAmount:uint256,
+    returnValue:uint256,
+  ) {
+    requireAddress(to);
 
-        super(
-            'CurveStethPoolWithdraw',
-            getAddr('CurveStethPoolWithdraw'),
-            ['address', 'address', 'uint256[2]', 'uint256', 'uint256'],
-            [from,to,amounts,maxBurnAmount,returnValue],
-        );
+    super(
+      'CurveStethPoolWithdraw',
+      getAddr('CurveStethPoolWithdraw'),
+      ['address', 'address', 'uint256[2]', 'uint256', 'uint256'],
+      [from, to, amounts, maxBurnAmount, returnValue],
+    );
 
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2][0],
-            this.args[2][1],
-            this.args[3],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2][0],
+      this.args[2][1],
+      this.args[3],
+    ];
+  }
 }

package/src/actions/curve/CurveSwapAction.ts

@@ -1,14 +1,13 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * @category Curve
  */
 export class CurveSwapAction extends Action {
-
-    /**
+  /**
      *
      * @param sender
      * @param receiver
@@ -18,23 +17,23 @@ export class CurveSwapAction extends Action {
      * @param amount
      * @param expected
      */
-    constructor(sender:EthAddress, receiver:EthAddress, pool:EthAddress, tokenA:EthAddress, tokenB:EthAddress, amount:uint256, expected:uint256) {
-        requireAddress(sender);
-        requireAddress(receiver);
-        super('CurveSwap',
-            getAddr('CurveSwap'),
-            ['address', 'address', 'address', 'address', 'address', 'uint256', 'uint256'],
-            [sender, receiver, pool, tokenA, tokenB, amount, expected]);
+  constructor(sender:EthAddress, receiver:EthAddress, pool:EthAddress, tokenA:EthAddress, tokenB:EthAddress, amount:uint256, expected:uint256) {
+    requireAddress(sender);
+    requireAddress(receiver);
+    super('CurveSwap',
+      getAddr('CurveSwap'),
+      ['address', 'address', 'address', 'address', 'address', 'uint256', 'uint256'],
+      [sender, receiver, pool, tokenA, tokenB, amount, expected]);
 
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[5],
-            this.args[6],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[5],
+      this.args[6],
+    ];
+  }
 
-    async getAssetsToApprove() {
-        return [{ asset: this.args[3], owner: this.args[0] }];
-    }
+  async getAssetsToApprove() {
+    return [{ asset: this.args[3], owner: this.args[0] }];
+  }
 }

package/src/actions/curve/CurveWithdrawAction.ts

@@ -1,18 +1,17 @@
-import {Action}  from '../../Action';
+import { Action } from '../../Action';
 import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
 import { poolInfo, makeFlags } from '../../utils/curve-utils';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 
 /**
  * @category Curve
  */
 export class CurveWithdrawAction extends Action {
+  lpToken:EthAddress;
 
-    lpToken:EthAddress;
-
-    /**
+  /**
      * @param sender
      * @param receiver
      * @param poolAddr
@@ -21,61 +20,61 @@ export class CurveWithdrawAction extends Action {
      * @param withdrawExact
      * @param minAmounts
      */
-    constructor(
-        sender:EthAddress,
-        receiver:EthAddress,
-        poolAddr:EthAddress,
-        burnAmount:uint256,
-        useUnderlying:boolean,
-        withdrawExact:boolean,
-        minAmounts:Array<uint256> = [],
-    ) {
-        requireAddress(sender);
-        requireAddress(receiver);
+  constructor(
+    sender:EthAddress,
+    receiver:EthAddress,
+    poolAddr:EthAddress,
+    burnAmount:uint256,
+    useUnderlying:boolean,
+    withdrawExact:boolean,
+    minAmounts:Array<uint256> = [],
+  ) {
+    requireAddress(sender);
+    requireAddress(receiver);
 
-        let depositTarget;
-        let depositTargetType = 0;
-        let explicitUnderlying = false;
+    let depositTarget;
+    let depositTargetType = 0;
+    let explicitUnderlying = false;
 
-        const pool = poolInfo.find((e:any) => e.swapAddr.toLowerCase() === poolAddr.toLowerCase())!;
-        if (useUnderlying) {
-            if (pool.depositContract) {
-                depositTarget = pool.depositContract;
-                depositTargetType = pool.zapType + 1;
-            } else {
-                depositTarget = pool.swapAddr;
-                explicitUnderlying = pool.underlyingFlag!;
-                if (!explicitUnderlying) throw Error('pool has no underlying deposit mechanism');
-            }
-        } else {
-            depositTarget = pool.swapAddr;
-        }
+    const pool = poolInfo.find((e:any) => e.swapAddr.toLowerCase() === poolAddr.toLowerCase())!;
+    if (useUnderlying) {
+      if (pool.depositContract) {
+        depositTarget = pool.depositContract;
+        depositTargetType = pool.zapType + 1;
+      } else {
+        depositTarget = pool.swapAddr;
+        explicitUnderlying = pool.underlyingFlag!;
+        if (!explicitUnderlying) throw Error('pool has no underlying deposit mechanism');
+      }
+    } else {
+      depositTarget = pool.swapAddr;
+    }
 
-        super('CurveWithdraw',
-            getAddr('CurveWithdraw'),
-            ['address', 'address', 'address', 'uint256', 'uint8', 'uint256[]'],
-            [
-                sender,
-                receiver,
-                depositTarget,
-                burnAmount,
-                makeFlags(depositTargetType, explicitUnderlying, withdrawExact),
-                minAmounts,
-            ],
-        );
-        this.lpToken = pool.lpToken;
+    super('CurveWithdraw',
+      getAddr('CurveWithdraw'),
+      ['address', 'address', 'address', 'uint256', 'uint8', 'uint256[]'],
+      [
+        sender,
+        receiver,
+        depositTarget,
+        burnAmount,
+        makeFlags(depositTargetType, explicitUnderlying, withdrawExact),
+        minAmounts,
+      ],
+    );
+    this.lpToken = pool.lpToken;
 
-        this.mappableArgs = [
-            this.args[0],
-            this.args[1],
-            this.args[2],
-            this.args[3],
-            this.args[4],
-            ...this.args[5],
-        ];
-    }
+    this.mappableArgs = [
+      this.args[0],
+      this.args[1],
+      this.args[2],
+      this.args[3],
+      this.args[4],
+      ...this.args[5],
+    ];
+  }
 
-    async getAssetsToApprove() {
-        return [{ asset: this.lpToken, owner: this.args[0] }];
-    }
+  async getAssetsToApprove() {
+    return [{ asset: this.lpToken, owner: this.args[0] }];
+  }
 }

package/src/actions/dydx/DyDxWithdrawAction.ts

@@ -1,21 +1,21 @@
-import {Action}  from "../../Action";
-import { requireAddress } from "../../utils/general";
+import { Action } from '../../Action';
+import { requireAddress } from '../../utils/general';
 import { getAddr } from '../../addresses';
-import {EthAddress,uint256} from '../../types';
+import { EthAddress, uint256 } from '../../types';
 
 /**
  * DyDxWithdrawAction - Withdraw token from an DyDx position
- * 
+ *
  * @category DyDx
  */
 export class DyDxWithdrawAction extends Action {
   /**
    * @param tokenAddr
-   * @param amount 
+   * @param amount
    * @param to Tokens will be withdrawn to this address
    */
   constructor(tokenAddr:EthAddress, amount:uint256, to:EthAddress) {
     requireAddress(to);
-    super('DyDxWithdraw', getAddr('DyDxWithdraw'), ['address','uint256','address'], [tokenAddr, amount, to]);
+    super('DyDxWithdraw', getAddr('DyDxWithdraw'), ['address', 'uint256', 'address'], [tokenAddr, amount, to]);
   }
 }