@uniswap/router-sdk 1.0.0-beta.7 → 1.0.2

package/dist/approveAndCall.d.ts

@@ -0,0 +1,22 @@
+import { Interface } from '@ethersproject/abi';
+import { Currency, Token } from '@uniswap/sdk-core';
+export declare enum ApprovalTypes {
+    NOT_REQUIRED = 0,
+    MAX = 1,
+    MAX_MINUS_ONE = 2,
+    ZERO_THEN_MAX = 3,
+    ZERO_THEN_MAX_MINUS_ONE = 4
+}
+export declare abstract class ApproveAndCall {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeApproveMax(token: Token): string;
+    static encodeApproveMaxMinusOne(token: Token): string;
+    static encodeApproveZeroThenMax(token: Token): string;
+    static encodeApproveZeroThenMaxMinusOne(token: Token): string;
+    static encodeCallPositionManager(calldatas: string[]): string;
+    static encodeApprove(token: Currency, approvalType: ApprovalTypes): string;
+}

package/dist/constants.d.ts

@@ -1,5 +1,5 @@
 import JSBI from 'jsbi';
-export declare const MSG_SENDER = "0x0000000000000000000000000000000000000000";
-export declare const ADDRESS_THIS = "0x0000000000000000000000000000000000000001";
+export declare const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+export declare const ADDRESS_THIS = "0x0000000000000000000000000000000000000002";
 export declare const ZERO: JSBI;
 export declare const ONE: JSBI;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './constants';
+export * from './approveAndCall';
 export * from './multicallExtended';
 export * from './paymentsExtended';
 export * from './swapRouter';

package/dist/router-sdk.cjs.development.js

@@ -6,19 +6,84 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 
 var JSBI = _interopDefault(require('jsbi'));
 var abi = require('@ethersproject/abi');
-var IMulticallExtended_json = require('@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IMulticallExtended.sol/IMulticallExtended.json');
+var invariant = _interopDefault(require('tiny-invariant'));
+var IApproveAndCall_json = require('@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IApproveAndCall.sol/IApproveAndCall.json');
 var v3Sdk = require('@uniswap/v3-sdk');
+var IMulticallExtended_json = require('@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IMulticallExtended.sol/IMulticallExtended.json');
 var sdkCore = require('@uniswap/sdk-core');
 var IPeripheryPaymentsWithFeeExtended_json = require('@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IPeripheryPaymentsWithFeeExtended.sol/IPeripheryPaymentsWithFeeExtended.json');
 var ISwapRouter02_json = require('@uniswap/swap-router-contracts/artifacts/contracts/interfaces/ISwapRouter02.sol/ISwapRouter02.json');
 var v2Sdk = require('@uniswap/v2-sdk');
-var invariant = _interopDefault(require('tiny-invariant'));
 
-var MSG_SENDER = '0x0000000000000000000000000000000000000000';
-var ADDRESS_THIS = '0x0000000000000000000000000000000000000001';
+var MSG_SENDER = '0x0000000000000000000000000000000000000001';
+var ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
 var ZERO = /*#__PURE__*/JSBI.BigInt(0);
 var ONE = /*#__PURE__*/JSBI.BigInt(1);
 
+(function (ApprovalTypes) {
+  ApprovalTypes[ApprovalTypes["NOT_REQUIRED"] = 0] = "NOT_REQUIRED";
+  ApprovalTypes[ApprovalTypes["MAX"] = 1] = "MAX";
+  ApprovalTypes[ApprovalTypes["MAX_MINUS_ONE"] = 2] = "MAX_MINUS_ONE";
+  ApprovalTypes[ApprovalTypes["ZERO_THEN_MAX"] = 3] = "ZERO_THEN_MAX";
+  ApprovalTypes[ApprovalTypes["ZERO_THEN_MAX_MINUS_ONE"] = 4] = "ZERO_THEN_MAX_MINUS_ONE";
+})(exports.ApprovalTypes || (exports.ApprovalTypes = {}));
+
+var ApproveAndCall = /*#__PURE__*/function () {
+  /**
+   * Cannot be constructed.
+   */
+  function ApproveAndCall() {}
+
+  ApproveAndCall.encodeApproveMax = function encodeApproveMax(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveMax', [token.address]);
+  };
+
+  ApproveAndCall.encodeApproveMaxMinusOne = function encodeApproveMaxMinusOne(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveMaxMinusOne', [token.address]);
+  };
+
+  ApproveAndCall.encodeApproveZeroThenMax = function encodeApproveZeroThenMax(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveZeroThenMax', [token.address]);
+  };
+
+  ApproveAndCall.encodeApproveZeroThenMaxMinusOne = function encodeApproveZeroThenMaxMinusOne(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveZeroThenMaxMinusOne', [token.address]);
+  };
+
+  ApproveAndCall.encodeCallPositionManager = function encodeCallPositionManager(calldatas) {
+    !(calldatas.length > 0) ?  invariant(false, 'NULL_CALLDATA')  : void 0;
+
+    if (calldatas.length == 1) {
+      return ApproveAndCall.INTERFACE.encodeFunctionData('callPositionManager', calldatas);
+    } else {
+      var encodedMulticall = v3Sdk.NonfungiblePositionManager.INTERFACE.encodeFunctionData('multicall', [calldatas]);
+      return ApproveAndCall.INTERFACE.encodeFunctionData('callPositionManager', [encodedMulticall]);
+    }
+  };
+
+  ApproveAndCall.encodeApprove = function encodeApprove(token, approvalType) {
+    switch (approvalType) {
+      case exports.ApprovalTypes.MAX:
+        return ApproveAndCall.encodeApproveMax(token.wrapped);
+
+      case exports.ApprovalTypes.MAX_MINUS_ONE:
+        return ApproveAndCall.encodeApproveMaxMinusOne(token.wrapped);
+
+      case exports.ApprovalTypes.ZERO_THEN_MAX:
+        return ApproveAndCall.encodeApproveZeroThenMax(token.wrapped);
+
+      case exports.ApprovalTypes.ZERO_THEN_MAX_MINUS_ONE:
+        return ApproveAndCall.encodeApproveZeroThenMaxMinusOne(token.wrapped);
+
+      default:
+        throw 'Error: invalid ApprovalType';
+    }
+  };
+
+  return ApproveAndCall;
+}();
+ApproveAndCall.INTERFACE = /*#__PURE__*/new abi.Interface(IApproveAndCall_json.abi);
+
 function validateAndParseBytes32(bytes32) {
   if (!bytes32.match(/^0x[0-9a-fA-F]{64}$/)) {
     throw new Error(bytes32 + " is not valid bytes32.");
@@ -216,11 +281,6 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
   throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-(function (Protocol) {
-  Protocol["V2"] = "V2";
-  Protocol["V3"] = "V3";
-})(exports.Protocol || (exports.Protocol = {}));
-
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
@@ -981,6 +1041,11 @@ try {
 }
 });
 
+(function (Protocol) {
+  Protocol["V2"] = "V2";
+  Protocol["V3"] = "V3";
+})(exports.Protocol || (exports.Protocol = {}));
+
 var RouteV2 = /*#__PURE__*/function (_V2RouteSDK) {
   _inheritsLoose(RouteV2, _V2RouteSDK);
 
@@ -1347,6 +1412,7 @@ var Trade = /*#__PURE__*/function () {
   return Trade;
 }();
 
+var ZERO$1 = /*#__PURE__*/JSBI.BigInt(0);
 /**
  * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
  */
@@ -1436,15 +1502,9 @@ var SwapRouter = /*#__PURE__*/function () {
     }
 
     return calldatas;
-  }
-  /**
-   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
-   * @param trade to produce call parameters for
-   * @param options options for the call parameters
-   */
-  ;
+  };
 
-  SwapRouter.swapCallParameters = function swapCallParameters(trades, options) {
+  SwapRouter.encodeSwaps = function encodeSwaps(trades, options, isSwapAndAdd) {
     // If dealing with an instance of the aggregated Trade object, unbundle it to individual V2Trade and V3Trade objects.
     if (trades instanceof Trade) {
       !trades.swaps.every(function (swap) {
@@ -1492,16 +1552,8 @@ var SwapRouter = /*#__PURE__*/function () {
       return trade.tradeType === sampleTrade.tradeType;
     }) ?  invariant(false, 'TRADE_TYPE_DIFF')  : void 0;
     var calldatas = [];
-    var ZERO_IN = sdkCore.CurrencyAmount.fromRawAmount(sampleTrade.inputAmount.currency, 0);
-    var ZERO_OUT = sdkCore.CurrencyAmount.fromRawAmount(sampleTrade.outputAmount.currency, 0);
-    var totalAmountOut = trades.reduce(function (sum, trade) {
-      return sum.add(trade.minimumAmountOut(options.slippageTolerance));
-    }, ZERO_OUT);
     var inputIsNative = sampleTrade.inputAmount.currency.isNative;
-    var outputIsNative = sampleTrade.outputAmount.currency.isNative; // flag for whether a refund needs to happen
-    //   1. when paying in ETH, but with an uncertain input amount
-
-    var mustRefund = inputIsNative && sampleTrade.tradeType === sdkCore.TradeType.EXACT_OUTPUT; // flag for whether we want to perform an aggregated slippage check
+    var outputIsNative = sampleTrade.outputAmount.currency.isNative; // flag for whether we want to perform an aggregated slippage check
     //   1. when there are >2 exact input trades. this is only a heuristic,
     //      as it's still more gas-expensive even in this case, but has benefits
     //      in that the reversion probability is lower
@@ -1509,12 +1561,10 @@ var SwapRouter = /*#__PURE__*/function () {
     var performAggregatedSlippageCheck = sampleTrade.tradeType === sdkCore.TradeType.EXACT_INPUT && numberOfTrades > 2; // flag for whether funds should be send first to the router
     //   1. when receiving ETH (which much be unwrapped from WETH)
     //   2. when a fee on the output is being taken
-    //   3. when performing an aggregated slippage check
+    //   3. when performing swap and add
+    //   4. when performing an aggregated slippage check
 
-    var routerMustCustody = outputIsNative || !!options.fee || performAggregatedSlippageCheck;
-    var totalValue = inputIsNative ? trades.reduce(function (sum, trade) {
-      return sum.add(trade.maximumAmountIn(options.slippageTolerance));
-    }, ZERO_IN) : ZERO_IN; // encode permit if necessary
+    var routerMustCustody = outputIsNative || !!options.fee || !!isSwapAndAdd || performAggregatedSlippageCheck; // encode permit if necessary
 
     if (options.inputTokenPermit) {
       !sampleTrade.inputAmount.currency.isToken ?  invariant(false, 'NON_TOKEN_PERMIT')  : void 0;
@@ -1532,7 +1582,42 @@ var SwapRouter = /*#__PURE__*/function () {
           calldatas.push(calldata);
         }
       }
-    } // unwrap or sweep
+    }
+
+    var ZERO_IN = sdkCore.CurrencyAmount.fromRawAmount(sampleTrade.inputAmount.currency, 0);
+    var ZERO_OUT = sdkCore.CurrencyAmount.fromRawAmount(sampleTrade.outputAmount.currency, 0);
+    var totalAmountOut = trades.reduce(function (sum, trade) {
+      return sum.add(trade.minimumAmountOut(options.slippageTolerance));
+    }, ZERO_OUT);
+    var totalAmountIn = trades.reduce(function (sum, trade) {
+      return sum.add(trade.maximumAmountIn(options.slippageTolerance));
+    }, ZERO_IN);
+    return {
+      calldatas: calldatas,
+      sampleTrade: sampleTrade,
+      routerMustCustody: routerMustCustody,
+      inputIsNative: inputIsNative,
+      outputIsNative: outputIsNative,
+      totalAmountIn: totalAmountIn,
+      totalAmountOut: totalAmountOut
+    };
+  }
+  /**
+   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+   * @param trade to produce call parameters for
+   * @param options options for the call parameters
+   */
+  ;
+
+  SwapRouter.swapCallParameters = function swapCallParameters(trades, options) {
+    var _SwapRouter$encodeSwa = SwapRouter.encodeSwaps(trades, options),
+        calldatas = _SwapRouter$encodeSwa.calldatas,
+        sampleTrade = _SwapRouter$encodeSwa.sampleTrade,
+        routerMustCustody = _SwapRouter$encodeSwa.routerMustCustody,
+        inputIsNative = _SwapRouter$encodeSwa.inputIsNative,
+        outputIsNative = _SwapRouter$encodeSwa.outputIsNative,
+        totalAmountIn = _SwapRouter$encodeSwa.totalAmountIn,
+        totalAmountOut = _SwapRouter$encodeSwa.totalAmountOut; // unwrap or sweep
 
 
     if (routerMustCustody) {
@@ -1541,16 +1626,93 @@ var SwapRouter = /*#__PURE__*/function () {
       } else {
         calldatas.push(PaymentsExtended.encodeSweepToken(sampleTrade.outputAmount.currency.wrapped, totalAmountOut.quotient, options.recipient, options.fee));
       }
-    } // refund
+    } // must refund when paying in ETH, but with an uncertain input amount
 
 
-    if (mustRefund) {
+    if (inputIsNative && sampleTrade.tradeType === sdkCore.TradeType.EXACT_OUTPUT) {
       calldatas.push(v3Sdk.Payments.encodeRefundETH());
     }
 
     return {
       calldata: MulticallExtended.encodeMulticall(calldatas, options.deadlineOrPreviousBlockhash),
-      value: v3Sdk.toHex(totalValue.quotient)
+      value: v3Sdk.toHex(inputIsNative ? totalAmountIn.quotient : ZERO$1)
+    };
+  }
+  /**
+   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+   * @param trade to produce call parameters for
+   * @param options options for the call parameters
+   */
+  ;
+
+  SwapRouter.swapAndAddCallParameters = function swapAndAddCallParameters(trades, options, position, addLiquidityOptions, tokenInApprovalType, tokenOutApprovalType) {
+    var _SwapRouter$encodeSwa2 = SwapRouter.encodeSwaps(trades, options, true),
+        calldatas = _SwapRouter$encodeSwa2.calldatas,
+        inputIsNative = _SwapRouter$encodeSwa2.inputIsNative,
+        outputIsNative = _SwapRouter$encodeSwa2.outputIsNative,
+        sampleTrade = _SwapRouter$encodeSwa2.sampleTrade,
+        totalAmountSwapped = _SwapRouter$encodeSwa2.totalAmountIn,
+        totalAmountOut = _SwapRouter$encodeSwa2.totalAmountOut;
+
+    var chainId = sampleTrade.route.chainId;
+    var zeroForOne = position.pool.token0 === totalAmountSwapped.currency.wrapped;
+
+    var _SwapRouter$getPositi = SwapRouter.getPositionAmounts(position, zeroForOne),
+        positionAmountIn = _SwapRouter$getPositi.positionAmountIn,
+        positionAmountOut = _SwapRouter$getPositi.positionAmountOut; // if tokens are native they will be converted to WETH9
+
+
+    var tokenIn = inputIsNative ? sdkCore.WETH9[chainId] : positionAmountIn.currency.wrapped;
+    var tokenOut = outputIsNative ? sdkCore.WETH9[chainId] : positionAmountOut.currency.wrapped; // if swap output does not make up whole outputTokenBalanceDesired, pull in remaining tokens for adding liquidity
+
+    var amountOutRemaining = positionAmountOut.subtract(totalAmountOut.wrapped);
+
+    if (amountOutRemaining.greaterThan(sdkCore.CurrencyAmount.fromRawAmount(positionAmountOut.currency, 0))) {
+      // if output is native, this means the remaining portion is included as native value in the transaction
+      // and must be wrapped. Otherwise, pull in remaining ERC20 token.
+      outputIsNative ? calldatas.push(PaymentsExtended.encodeWrapETH(amountOutRemaining.quotient)) : calldatas.push(PaymentsExtended.encodePull(tokenOut, amountOutRemaining.quotient));
+    } // if input is native, convert to WETH9, else pull ERC20 token
+
+
+    inputIsNative ? calldatas.push(PaymentsExtended.encodeWrapETH(positionAmountIn.quotient)) : calldatas.push(PaymentsExtended.encodePull(tokenIn, positionAmountIn.quotient)); // approve token balances to NFTManager
+
+    if (tokenInApprovalType !== exports.ApprovalTypes.NOT_REQUIRED) calldatas.push(ApproveAndCall.encodeApprove(tokenIn, tokenInApprovalType));
+    if (tokenOutApprovalType !== exports.ApprovalTypes.NOT_REQUIRED) calldatas.push(ApproveAndCall.encodeApprove(tokenOut, tokenOutApprovalType)); // encode NFTManager add liquidity
+
+    calldatas.push(ApproveAndCall.encodeCallPositionManager([v3Sdk.NonfungiblePositionManager.addCallParameters(position, addLiquidityOptions).calldata])); // sweep remaining tokens
+
+    inputIsNative ? calldatas.push(PaymentsExtended.encodeUnwrapWETH9(ZERO$1)) : calldatas.push(PaymentsExtended.encodeSweepToken(tokenIn, ZERO$1));
+    outputIsNative ? calldatas.push(PaymentsExtended.encodeUnwrapWETH9(ZERO$1)) : calldatas.push(PaymentsExtended.encodeSweepToken(tokenOut, ZERO$1));
+    var value;
+
+    if (inputIsNative) {
+      value = totalAmountSwapped.wrapped.add(positionAmountIn.wrapped).quotient;
+    } else if (outputIsNative) {
+      value = amountOutRemaining.quotient;
+    } else {
+      value = ZERO$1;
+    }
+
+    return {
+      calldata: MulticallExtended.encodeMulticall(calldatas, options.deadlineOrPreviousBlockhash),
+      value: value.toString()
+    };
+  };
+
+  SwapRouter.getPositionAmounts = function getPositionAmounts(position, zeroForOne) {
+    var _position$mintAmounts = position.mintAmounts,
+        amount0 = _position$mintAmounts.amount0,
+        amount1 = _position$mintAmounts.amount1;
+    var currencyAmount0 = sdkCore.CurrencyAmount.fromRawAmount(position.pool.token0, amount0);
+    var currencyAmount1 = sdkCore.CurrencyAmount.fromRawAmount(position.pool.token1, amount1);
+
+    var _ref = zeroForOne ? [currencyAmount0, currencyAmount1] : [currencyAmount1, currencyAmount0],
+        positionAmountIn = _ref[0],
+        positionAmountOut = _ref[1];
+
+    return {
+      positionAmountIn: positionAmountIn,
+      positionAmountOut: positionAmountOut
     };
   };
 
@@ -1559,6 +1721,7 @@ var SwapRouter = /*#__PURE__*/function () {
 SwapRouter.INTERFACE = /*#__PURE__*/new abi.Interface(ISwapRouter02_json.abi);
 
 exports.ADDRESS_THIS = ADDRESS_THIS;
+exports.ApproveAndCall = ApproveAndCall;
 exports.MSG_SENDER = MSG_SENDER;
 exports.MulticallExtended = MulticallExtended;
 exports.ONE = ONE;