@uniswap/universal-router-sdk 1.5.0-beta.2 → 1.5.0-beta.3

package/dist/entities/protocols/looksRareV2.d.ts

@@ -37,8 +37,8 @@ export declare type LRV2APIOrder = MakerOrder & {
     hash: string;
     signature: string;
     createdAt: string;
-    merkleRoot: string;
-    merkleProof: MerkleProof[];
+    merkleRoot?: string;
+    merkleProof?: MerkleProof[];
     status: string;
 };
 export declare type LooksRareV2Data = {

package/dist/entities/protocols/seaport.d.ts

@@ -58,6 +58,7 @@ export declare class SeaportTrade extends NFTTrade<SeaportData> {
     constructor(orders: SeaportData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
+    getInputTokens(): Set<string>;
     getTotalOrderPrice(order: SeaportData, token?: string): BigNumber;
     getTotalPrice(token?: string): BigNumber;
     private commandMap;

package/dist/swapRouter.d.ts

@@ -16,6 +16,7 @@ export declare abstract class SwapRouter {
     static swapCallParameters(trades: Command[] | Command, config?: SwapRouterConfig): MethodParameters;
     /**
      * @deprecated in favor of swapCallParameters. Update before next major version 2.0.0
+     * This version does not work correctly for Seaport ERC20->NFT purchases
      * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given swap.
      * @param trades to produce call parameters for
      */

package/dist/test/orders/seaportV1_4.d.ts

@@ -1,3 +1,4 @@
 import { SeaportData } from '../../src/entities/protocols/seaport';
 export declare const seaportV1_4DataETH: SeaportData;
 export declare const seaportV1_4DataETHRecent: SeaportData;
+export declare const seaportV1_4DataERC20: SeaportData;

package/dist/test/orders/{seaport.d.ts → seaportV1_5.d.ts}

@@ -1,5 +1,4 @@
 import { ConsiderationItem, SeaportData } from '../../src/entities/protocols/seaport';
 import { BigNumber } from 'ethers';
-export declare const seaportDataETH: SeaportData;
-export declare const seaportDataERC20: SeaportData;
+export declare const seaportV1_5DataETH: SeaportData;
 export declare function calculateSeaportValue(considerations: ConsiderationItem[], token: string): BigNumber;

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

@@ -79,6 +79,29 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
   RouterTradeType["UnwrapWETH"] = "UnwrapWETH";
 })(exports.RouterTradeType || (exports.RouterTradeType = {}));
 
+var NFTTrade = function NFTTrade(market, orders) {
+  this.tradeType = exports.RouterTradeType.NFTTrade;
+  !(orders.length > 0) ?  invariant(false, 'no buy Items')  : void 0;
+  this.market = market;
+  this.orders = orders;
+};
+(function (Market) {
+  Market["Foundation"] = "foundation";
+  Market["LooksRareV2"] = "looksrareV2";
+  Market["NFT20"] = "nft20";
+  Market["NFTX"] = "nftx";
+  Market["Seaport"] = "seaport";
+  Market["Sudoswap"] = "Sudoswap";
+  Market["Cryptopunks"] = "cryptopunks";
+  Market["X2Y2"] = "x2y2";
+  Market["Element"] = "element";
+})(exports.Market || (exports.Market = {}));
+(function (TokenType) {
+  TokenType["ERC721"] = "ERC721";
+  TokenType["ERC1155"] = "ERC1155";
+  TokenType["Cryptopunk"] = "Cryptopunk";
+})(exports.TokenType || (exports.TokenType = {}));
+
 var _ABI_DEFINITION;
 /**
  * CommandTypes
@@ -436,7 +459,7 @@ function encodeInputTokenOptions(planner, options) {
 }
 function mapApprovalProtocol(protocolAddress) {
   switch (protocolAddress.toLowerCase()) {
-    case '0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC':
+    case '0x00000000000000adc04c56bf30ac9d3c0aaf14dc':
       // Seaport v1.5
       return OPENSEA_CONDUIT_SPENDER_ID;
     case '0x00000000000001ad428e4906ae43d8f9852d0dd6':
@@ -465,6 +488,8 @@ var SwapRouter = /*#__PURE__*/function () {
     // track value flow to require the right amount of native value
     var currentNativeValueInRouter = ethers.BigNumber.from(0);
     var transactionValue = ethers.BigNumber.from(0);
+    // tracks the input tokens (and ETH) used to buy NFTs to allow us to sweep
+    var nftInputTokens = new Set();
     for (var _iterator = _createForOfIteratorHelperLoose(trades), _step; !(_step = _iterator()).done;) {
       var trade = _step.value;
       /**
@@ -476,6 +501,15 @@ var SwapRouter = /*#__PURE__*/function () {
           allowRevert: allowRevert
         });
         var tradePrice = nftTrade.getTotalPrice();
+        if (nftTrade.market == exports.Market.Seaport) {
+          var seaportTrade = nftTrade;
+          var seaportInputTokens = seaportTrade.getInputTokens();
+          seaportInputTokens.forEach(function (inputToken) {
+            nftInputTokens.add(inputToken);
+          });
+        } else {
+          nftInputTokens.add(ETH_ADDRESS);
+        }
         // send enough native value to contract for NFT purchase
         if (currentNativeValueInRouter.lt(tradePrice)) {
           transactionValue = transactionValue.add(tradePrice.sub(currentNativeValueInRouter));
@@ -524,11 +558,14 @@ var SwapRouter = /*#__PURE__*/function () {
     // TODO: matches current logic for now, but should eventually only sweep for multiple NFT trades
     // or NFT trades with potential slippage (i.e. sudo).
     // Note: NFTXV2 sends excess ETH to the caller (router), not the specified recipient
-    if (nftTrades.length > 0) planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, SENDER_AS_RECIPIENT, 0]);
+    nftInputTokens.forEach(function (inputToken) {
+      planner.addCommand(CommandType.SWEEP, [inputToken, SENDER_AS_RECIPIENT, 0]);
+    });
     return SwapRouter.encodePlan(planner, transactionValue, config);
   }
   /**
    * @deprecated in favor of swapCallParameters. Update before next major version 2.0.0
+   * This version does not work correctly for Seaport ERC20->NFT purchases
    * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given swap.
    * @param trades to produce call parameters for
    */;
@@ -596,29 +633,6 @@ var SwapRouter = /*#__PURE__*/function () {
 }();
 SwapRouter.INTERFACE = /*#__PURE__*/new abi$7.Interface(UniversalRouter_json.abi);
 
-var NFTTrade = function NFTTrade(market, orders) {
-  this.tradeType = exports.RouterTradeType.NFTTrade;
-  !(orders.length > 0) ?  invariant(false, 'no buy Items')  : void 0;
-  this.market = market;
-  this.orders = orders;
-};
-(function (Market) {
-  Market["Foundation"] = "foundation";
-  Market["LooksRareV2"] = "looksrareV2";
-  Market["NFT20"] = "nft20";
-  Market["NFTX"] = "nftx";
-  Market["Seaport"] = "seaport";
-  Market["Sudoswap"] = "Sudoswap";
-  Market["Cryptopunks"] = "cryptopunks";
-  Market["X2Y2"] = "x2y2";
-  Market["Element"] = "element";
-})(exports.Market || (exports.Market = {}));
-(function (TokenType) {
-  TokenType["ERC721"] = "ERC721";
-  TokenType["ERC1155"] = "ERC1155";
-  TokenType["Cryptopunk"] = "Cryptopunk";
-})(exports.TokenType || (exports.TokenType = {}));
-
 var CryptopunkTrade = /*#__PURE__*/function (_NFTTrade) {
   _inheritsLoose(CryptopunkTrade, _NFTTrade);
   function CryptopunkTrade(orders) {
@@ -4321,26 +4335,28 @@ var LooksRareV2Trade = /*#__PURE__*/function (_NFTTrade) {
   }
   var _proto = LooksRareV2Trade.prototype;
   _proto.encode = function encode(planner, config) {
-    for (var _iterator = _createForOfIteratorHelperLoose(this.orders), _step; !(_step = _iterator()).done;) {
-      var item = _step.value;
-      var _this$refactorAPIData = this.refactorAPIData(item),
-        takerBid = _this$refactorAPIData.takerBid,
-        makerOrder = _this$refactorAPIData.makerOrder,
-        makerSignature = _this$refactorAPIData.makerSignature,
-        value = _this$refactorAPIData.value,
-        merkleTree = _this$refactorAPIData.merkleTree;
-      var calldata = LooksRareV2Trade.INTERFACE.encodeFunctionData('executeTakerBid', [takerBid, makerOrder, makerSignature, merkleTree, ZERO_ADDRESS]);
-      planner.addCommand(CommandType.LOOKS_RARE_V2, [value, calldata], config.allowRevert);
+    var _this$refactorAPIData = this.refactorAPIData(this.orders),
+      takerBids = _this$refactorAPIData.takerBids,
+      makerOrders = _this$refactorAPIData.makerOrders,
+      makerSignatures = _this$refactorAPIData.makerSignatures,
+      totalValue = _this$refactorAPIData.totalValue,
+      merkleTrees = _this$refactorAPIData.merkleTrees;
+    var calldata;
+    if (this.orders.length == 1) {
+      calldata = LooksRareV2Trade.INTERFACE.encodeFunctionData('executeTakerBid', [takerBids[0], makerOrders[0], makerSignatures[0], merkleTrees[0], ZERO_ADDRESS]);
+    } else {
+      calldata = LooksRareV2Trade.INTERFACE.encodeFunctionData('executeMultipleTakerBids', [takerBids, makerOrders, makerSignatures, merkleTrees, ZERO_ADDRESS, false]);
     }
+    planner.addCommand(CommandType.LOOKS_RARE_V2, [totalValue, calldata], config.allowRevert);
   };
   _proto.getBuyItems = function getBuyItems() {
     var buyItems = [];
-    for (var _iterator2 = _createForOfIteratorHelperLoose(this.orders), _step2; !(_step2 = _iterator2()).done;) {
-      var item = _step2.value;
+    for (var _iterator = _createForOfIteratorHelperLoose(this.orders), _step; !(_step = _iterator()).done;) {
+      var item = _step.value;
       var tokenAddress = item.apiOrder.collection;
       var tokenType = item.apiOrder.collectionType == LooksRareV2Trade.ERC721_ORDER ? exports.TokenType.ERC721 : exports.TokenType.ERC1155;
-      for (var _iterator3 = _createForOfIteratorHelperLoose(item.apiOrder.itemIds), _step3; !(_step3 = _iterator3()).done;) {
-        var tokenId = _step3.value;
+      for (var _iterator2 = _createForOfIteratorHelperLoose(item.apiOrder.itemIds), _step2; !(_step2 = _iterator2()).done;) {
+        var tokenId = _step2.value;
         buyItems.push({
           tokenAddress: tokenAddress,
           tokenId: tokenId,
@@ -4352,30 +4368,38 @@ var LooksRareV2Trade = /*#__PURE__*/function (_NFTTrade) {
   };
   _proto.getTotalPrice = function getTotalPrice() {
     var total = ethers.BigNumber.from(0);
-    for (var _iterator4 = _createForOfIteratorHelperLoose(this.orders), _step4; !(_step4 = _iterator4()).done;) {
-      var item = _step4.value;
+    for (var _iterator3 = _createForOfIteratorHelperLoose(this.orders), _step3; !(_step3 = _iterator3()).done;) {
+      var item = _step3.value;
       total = total.add(item.apiOrder.price);
     }
     return total;
   };
-  _proto.refactorAPIData = function refactorAPIData(data) {
-    var makerOrder = _extends({}, data.apiOrder);
-    var makerSignature = data.apiOrder.signature;
-    var takerBid = {
-      recipient: data.taker,
-      additionalParameters: '0x'
-    };
-    var value = ethers.BigNumber.from(data.apiOrder.price);
-    var merkleTree = {
-      root: data.apiOrder.merkleRoot,
-      proof: data.apiOrder.merkleProof
-    };
+  _proto.refactorAPIData = function refactorAPIData(orders) {
+    var takerBids = [];
+    var makerOrders = [];
+    var makerSignatures = [];
+    var totalValue = ethers.BigNumber.from(0);
+    var merkleTrees = [];
+    orders.forEach(function (order) {
+      var _order$apiOrder$merkl, _order$apiOrder$merkl2;
+      makerOrders.push(_extends({}, order.apiOrder));
+      makerSignatures.push(order.apiOrder.signature);
+      takerBids.push({
+        recipient: order.taker,
+        additionalParameters: '0x'
+      });
+      totalValue = totalValue.add(ethers.BigNumber.from(order.apiOrder.price));
+      merkleTrees.push({
+        root: (_order$apiOrder$merkl = order.apiOrder.merkleRoot) != null ? _order$apiOrder$merkl : '0x0000000000000000000000000000000000000000000000000000000000000000',
+        proof: (_order$apiOrder$merkl2 = order.apiOrder.merkleProof) != null ? _order$apiOrder$merkl2 : []
+      });
+    });
     return {
-      takerBid: takerBid,
-      makerOrder: makerOrder,
-      makerSignature: makerSignature,
-      value: value,
-      merkleTree: merkleTree
+      takerBids: takerBids,
+      makerOrders: makerOrders,
+      makerSignatures: makerSignatures,
+      totalValue: totalValue,
+      merkleTrees: merkleTrees
     };
   };
   return LooksRareV2Trade;
@@ -8035,13 +8059,28 @@ var SeaportTrade = /*#__PURE__*/function (_NFTTrade) {
     }
     return buyItems;
   };
+  _proto.getInputTokens = function getInputTokens() {
+    var inputTokens = new Set();
+    for (var _iterator7 = _createForOfIteratorHelperLoose(this.orders), _step7; !(_step7 = _iterator7()).done;) {
+      var order = _step7.value;
+      for (var _iterator8 = _createForOfIteratorHelperLoose(order.items), _step8; !(_step8 = _iterator8()).done;) {
+        var item = _step8.value;
+        for (var _iterator9 = _createForOfIteratorHelperLoose(item.parameters.consideration), _step9; !(_step9 = _iterator9()).done;) {
+          var consideration = _step9.value;
+          var token = consideration.token.toLowerCase();
+          inputTokens.add(token);
+        }
+      }
+    }
+    return inputTokens;
+  };
   _proto.getTotalOrderPrice = function getTotalOrderPrice(order, token) {
     if (token === void 0) {
       token = ETH_ADDRESS;
     }
     var totalOrderPrice = ethers.BigNumber.from(0);
-    for (var _iterator7 = _createForOfIteratorHelperLoose(order.items), _step7; !(_step7 = _iterator7()).done;) {
-      var item = _step7.value;
+    for (var _iterator10 = _createForOfIteratorHelperLoose(order.items), _step10; !(_step10 = _iterator10()).done;) {
+      var item = _step10.value;
       totalOrderPrice = totalOrderPrice.add(this.calculateValue(item.parameters.consideration, token));
     }
     return totalOrderPrice;
@@ -8051,10 +8090,10 @@ var SeaportTrade = /*#__PURE__*/function (_NFTTrade) {
       token = ETH_ADDRESS;
     }
     var totalPrice = ethers.BigNumber.from(0);
-    for (var _iterator8 = _createForOfIteratorHelperLoose(this.orders), _step8; !(_step8 = _iterator8()).done;) {
-      var order = _step8.value;
-      for (var _iterator9 = _createForOfIteratorHelperLoose(order.items), _step9; !(_step9 = _iterator9()).done;) {
-        var item = _step9.value;
+    for (var _iterator11 = _createForOfIteratorHelperLoose(this.orders), _step11; !(_step11 = _iterator11()).done;) {
+      var order = _step11.value;
+      for (var _iterator12 = _createForOfIteratorHelperLoose(order.items), _step12; !(_step12 = _iterator12()).done;) {
+        var item = _step12.value;
         totalPrice = totalPrice.add(this.calculateValue(item.parameters.consideration, token));
       }
     }
@@ -8062,7 +8101,7 @@ var SeaportTrade = /*#__PURE__*/function (_NFTTrade) {
   };
   _proto.commandMap = function commandMap(protocolAddress) {
     switch (protocolAddress.toLowerCase()) {
-      case '0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC':
+      case '0x00000000000000adc04c56bf30ac9d3c0aaf14dc':
         // Seaport v1.5
         return CommandType.SEAPORT_V1_5;
       case '0x00000000000001ad428e4906ae43d8f9852d0dd6':
@@ -8119,7 +8158,7 @@ var SeaportTrade = /*#__PURE__*/function (_NFTTrade) {
   };
   _proto.calculateValue = function calculateValue(considerations, token) {
     return considerations.reduce(function (amt, consideration) {
-      return consideration.token == token ? amt.add(consideration.startAmount) : amt;
+      return consideration.token.toLowerCase() == token.toLowerCase() ? amt.add(consideration.startAmount) : amt;
     }, ethers.BigNumber.from(0));
   };
   return SeaportTrade;
@@ -10447,7 +10486,7 @@ var UnwrapWETH = /*#__PURE__*/function () {
     this.wethAddress = WETH_ADDRESS(chainId);
     this.amount = amount;
     if (!!permit2) {
-      !(permit2.details.token === this.wethAddress) ?  invariant(false, "must be permitting WETH address: " + this.wethAddress)  : void 0;
+      !(permit2.details.token.toLowerCase() === this.wethAddress.toLowerCase()) ?  invariant(false, "must be permitting WETH address: " + this.wethAddress)  : void 0;
       !(permit2.details.amount >= amount) ?  invariant(false, "Did not permit enough WETH for unwrapWETH transaction")  : void 0;
       this.permit2Data = permit2;
     }