@uniswap/uniswapx-sdk - npm Package Compare versions

Comparing version 2.0.1-alpha.2 to 2.0.1-alpha.3

dist/src/builder/V2DutchOrderBuilder.js

@@ -216,6 +216,6 @@ "use strict";
         (0, tiny_invariant_1.default)(this.info.cosignerData.inputOverride !== undefined &&
-            this.info.cosignerData.inputOverride.gte(this.info.input.startAmount), "inputOverride not set or smaller than original input");
+            this.info.cosignerData.inputOverride.lte(this.info.input.startAmount), "inputOverride not set or larger than original input");
         (0, tiny_invariant_1.default)(this.info.cosignerData.outputOverrides.length > 0, "outputOverrides not set");
         this.info.cosignerData.outputOverrides.forEach((override, idx) => {
-            (0, tiny_invariant_1.default)(override.lte(this.info.outputs[idx].startAmount), "outputOverride must not be larger than original output");
+            (0, tiny_invariant_1.default)(override.gte(this.info.outputs[idx].startAmount), "outputOverride must be larger than or equal to original output");
         });
@@ -222,0 +222,0 @@ (0, tiny_invariant_1.default)(this.info.input !== undefined, "original input not set");

dist/src/builder/V2DutchOrderBuilder.test.js

@@ -37,4 +37,4 @@ "use strict";
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(99).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT])
             .build();
@@ -69,4 +69,4 @@ expect(order.info.cosignerData.decayStartTime).toEqual(deadline - 100);
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT)
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .validation(validationInfo)
@@ -109,4 +109,4 @@ .build();
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .validation(validationInfo)
@@ -143,4 +143,4 @@ .build();
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .validation(validationInfo)
@@ -180,4 +180,4 @@ .build();
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build();
@@ -207,4 +207,4 @@ expect(order.info.cosignerData.decayStartTime).toEqual(deadline - 100);
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow("Invariant failed: cosigner not set");
@@ -232,4 +232,4 @@ });
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow("Invariant failed: swapper not set");
@@ -256,4 +256,4 @@ });
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow("Invariant failed: deadline not set");
@@ -281,7 +281,7 @@ });
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow("Invariant failed: nonce not set");
     });
-    it("inputOverride smaller than input", () => {
+    it("inputOverride larger than input", () => {
         const deadline = Math.floor(Date.now() / 1000) + 1000;
@@ -307,7 +307,7 @@ expect(() => builder
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(99).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
-            .build()).toThrow("Invariant failed: inputOverride not set or smaller than original input");
+            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
+            .build()).toThrow("Invariant failed: inputOverride not set or larger than original input");
     });
-    it("outputOverride larger than output", () => {
+    it("outputOverride smaller than output", () => {
         const deadline = Math.floor(Date.now() / 1000) + 1000;
@@ -333,5 +333,5 @@ expect(() => builder
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
-            .build()).toThrow("Invariant failed: outputOverride must not be larger than original output");
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .build()).toThrow("Invariant failed: outputOverride must be larger than or equal to original output");
     });
@@ -358,4 +358,4 @@ it("decayEndTime defaults to deadline", () => {
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build();
@@ -385,4 +385,4 @@ expect(order.info.cosignerData.decayEndTime).toEqual(deadline);
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build();
@@ -413,4 +413,4 @@ expect(order.info.deadline).toEqual(decayEndTime);
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow("startAmount must be greater than endAmount: 100");
@@ -439,4 +439,4 @@ });
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(89).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow("Invariant failed: Deadline must be in the future: 1234");
@@ -465,4 +465,4 @@ });
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow(`Invariant failed: decayStartTime must be before or same as deadline: ${deadline + 100}`);
@@ -491,4 +491,4 @@ });
         })
-            .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
-            .outputOverrides([OUTPUT_START_AMOUNT.mul(98).div(100)])
+            .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
+            .outputOverrides([OUTPUT_START_AMOUNT.mul(102).div(100)])
             .build()).toThrow(`Invariant failed: decayEndTime must be before or same as deadline: ${deadline + 100}`);
@@ -545,3 +545,3 @@ });
             })
-                .inputOverride(INPUT_START_AMOUNT.mul(102).div(100))
+                .inputOverride(INPUT_START_AMOUNT.mul(98).div(100))
                 .buildPartial();
@@ -548,0 +548,0 @@ expect(order.info.outputs.length).toEqual(1);

dist/src/constants.js

@@ -34,3 +34,3 @@ "use strict";
     [OrderType.Dutch_V2]: "0x0000000000000000000000000000000000000000",
-    [OrderType.Relay]: "0x0000000000000000000000000000000000000001",
+    [OrderType.Relay]: "0x0000000000A4e21E2597DCac987455c48b12edBF",
 })), { 
@@ -41,7 +41,7 @@ //test contract is only on mainnet
         [OrderType.Dutch_V2]: "0x3867393cC6EA7b0414C2c3e1D9fe7cEa987Fd066",
-        [OrderType.Relay]: "0x0000000000000000000000000000000000000001",
+        [OrderType.Relay]: "0x0000000000A4e21E2597DCac987455c48b12edBF",
     }, 12341234: {
         [OrderType.Dutch]: "0xbD7F9D0239f81C94b728d827a87b9864972661eC",
         [OrderType.Dutch_V2]: "0x0000000000000000000000000000000000000000",
-        [OrderType.Relay]: "0x0000000000000000000000000000000000000001",
+        [OrderType.Relay]: "0x0000000000A4e21E2597DCac987455c48b12edBF",
     } });
@@ -51,7 +51,7 @@ exports.REACTOR_CONTRACT_MAPPING = Object.assign(Object.assign({}, constructSameAddressMap({
     [OrderType.Dutch_V2]: "0x0000000000000000000000000000000000000000",
-    [OrderType.Relay]: "0x0000000000000000000000000000000000000001",
+    [OrderType.Relay]: "0x0000000000A4e21E2597DCac987455c48b12edBF",
 })), { 12341234: {
         [OrderType.Dutch]: "0xbD7F9D0239f81C94b728d827a87b9864972661eC",
         [OrderType.Dutch_V2]: "0x0000000000000000000000000000000000000000",
-        [OrderType.Relay]: "0x0000000000000000000000000000000000000001",
+        [OrderType.Relay]: "0x0000000000A4e21E2597DCac987455c48b12edBF",
     } });
@@ -58,0 +58,0 @@ // https://github.com/mds1/multicall

dist/src/constants.test.js

@@ -11,3 +11,3 @@ "use strict";
         "Dutch_V2": "0x3867393cC6EA7b0414C2c3e1D9fe7cEa987Fd066",
-        "Relay": "0x0000000000000000000000000000000000000001",
+        "Relay": "0x0000000000A4e21E2597DCac987455c48b12edBF",
       },
@@ -17,3 +17,3 @@ "12341234": {
         "Dutch_V2": "0x0000000000000000000000000000000000000000",
-        "Relay": "0x0000000000000000000000000000000000000001",
+        "Relay": "0x0000000000A4e21E2597DCac987455c48b12edBF",
       },
@@ -23,3 +23,3 @@ "137": {
         "Dutch_V2": "0x0000000000000000000000000000000000000000",
-        "Relay": "0x0000000000000000000000000000000000000001",
+        "Relay": "0x0000000000A4e21E2597DCac987455c48b12edBF",
       },
@@ -29,3 +29,3 @@ "5": {
         "Dutch_V2": "0x0000000000000000000000000000000000000000",
-        "Relay": "0x0000000000000000000000000000000000000001",
+        "Relay": "0x0000000000A4e21E2597DCac987455c48b12edBF",
       },
@@ -32,0 +32,0 @@ }

dist/src/order/V2DutchOrder.d.ts

@@ -78,3 +78,3 @@ import { SignatureLike } from "@ethersproject/bytes";
     /**
-     * Hash signed over by the cosigner
+     * Full order hash that should be signed over by the cosigner
      */
@@ -81,0 +81,0 @@ cosignatureHash(cosignerData: CosignerData): string;

dist/src/order/V2DutchOrder.js

@@ -191,3 +191,3 @@ "use strict";
     /**
-     * Hash signed over by the cosigner
+     * Full order hash that should be signed over by the cosigner
      */
@@ -194,0 +194,0 @@ cosignatureHash(cosignerData) {

dist/src/utils/order.d.ts

 import { OrderType } from "../constants";
 import { Order } from "../order";
 declare abstract class OrderParser {
-    abstract offset: number;
+    abstract orderInfoOffset: number;
     abstract parseOrder(order: string, chainId: number): Order;
@@ -22,3 +22,3 @@ /**
 export declare class UniswapXOrderParser extends OrderParser {
-    offset: number;
+    orderInfoOffset: number;
     /**
@@ -35,3 +35,3 @@ * Parses a serialized order
 export declare class RelayOrderParser extends OrderParser {
-    offset: number;
+    orderInfoOffset: number;
     /**
@@ -38,0 +38,0 @@ * Parses a serialized order

dist/src/utils/order.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelayOrderParser = exports.UniswapXOrderParser = void 0;
+const ethers_1 = require("ethers");
 const constants_1 = require("../constants");
@@ -8,4 +9,5 @@ const errors_1 = require("../errors");
 const _1 = require(".");
-const UNISWAPX_FIRST_FIELD_OFFSET = 664;
-const RELAY_FIRST_FIELD_OFFSET = 88;
+const UNISWAPX_ORDER_INFO_OFFSET = 64;
+const RELAY_ORDER_INFO_OFFSET = 64;
+const SLOT_LENGTH = 64;
 const ADDRESS_LENGTH = 40;
@@ -18,10 +20,19 @@ class OrderParser {
     _parseOrder(order) {
-        const reactor = "0x" +
-            (0, _1.stripHexPrefix)(order)
-                .slice(this.offset, this.offset + ADDRESS_LENGTH)
-                .toLowerCase();
-        if (!constants_1.REVERSE_REACTOR_MAPPING[reactor]) {
-            throw new errors_1.MissingConfiguration("reactor", reactor);
+        const strippedOrder = (0, _1.stripHexPrefix)(order);
+        // look up the tail offset of orderInfo
+        // orderInfo is always the first field in the order,
+        // but since it is dynamic size it is a pointer in the tail
+        const orderInfoOffsetBytes = parseInt(strippedOrder.slice(this.orderInfoOffset, this.orderInfoOffset + SLOT_LENGTH), 16);
+        // multiply tail offset by 2 to get in terms of hex characters instead of bytes
+        // and add one slot to skip the orderinfo size slot
+        const reactorAddressOffset = orderInfoOffsetBytes * 2 + SLOT_LENGTH;
+        const reactorAddressSlot = strippedOrder.slice(reactorAddressOffset, reactorAddressOffset + SLOT_LENGTH);
+        // slice off the 0 padding in front of the address
+        const reactorAddress = ethers_1.ethers.utils
+            .getAddress(reactorAddressSlot.slice(SLOT_LENGTH - ADDRESS_LENGTH))
+            .toLowerCase();
+        if (!constants_1.REVERSE_REACTOR_MAPPING[reactorAddress]) {
+            throw new errors_1.MissingConfiguration("reactor", reactorAddress);
         }
-        return constants_1.REVERSE_REACTOR_MAPPING[reactor].orderType;
+        return constants_1.REVERSE_REACTOR_MAPPING[reactorAddress].orderType;
     }
@@ -47,3 +58,3 @@ /**
         super(...arguments);
-        this.offset = UNISWAPX_FIRST_FIELD_OFFSET;
+        this.orderInfoOffset = UNISWAPX_ORDER_INFO_OFFSET;
     }
@@ -92,3 +103,3 @@ /**
         super(...arguments);
-        this.offset = RELAY_FIRST_FIELD_OFFSET;
+        this.orderInfoOffset = RELAY_ORDER_INFO_OFFSET;
     }
@@ -95,0 +106,0 @@ /**

dist/src/utils/order.test.js

@@ -6,3 +6,4 @@ "use strict";
 const constants_1 = require("../constants");
-const order_1 = require("./order");
+const order_1 = require("../order");
+const order_2 = require("./order");
 describe("order utils", () => {
@@ -16,4 +17,4 @@ let dutchOrder;
     let chainId;
-    const uniswapXOrderParser = new order_1.UniswapXOrderParser();
-    const relayOrderParser = new order_1.RelayOrderParser();
+    const uniswapXOrderParser = new order_2.UniswapXOrderParser();
+    const relayOrderParser = new order_2.RelayOrderParser();
     beforeAll(() => {
@@ -113,4 +114,3 @@ chainId = 1;
         })
-            .inputOverride(ethers_1.BigNumber.from("100000000000000000000"))
-            .outputOverrides([ethers_1.BigNumber.from(0)]);
+            .outputOverrides([ethers_1.BigNumber.from("100000000000000000000")]);
         unsignedV2DutchOrder = v2Builder.buildPartial();
@@ -130,2 +130,42 @@ cosignedV2DutchOrder = v2Builder
         });
+        it("parses CosignedV2DutchOrder 2", () => {
+            const FROM_ADDRESS = "0xabCd111111111111111111111111111111111111";
+            const USDC_MAINNET_CHECKSUMMED_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+            const TIMESTAMP_SECONDS = 1660562791;
+            const WETH_MAINNET_CHECKSUMMED_ADDRESS = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+            const ENCODED_DUTCH_V2_ORDER = new builder_1.V2DutchOrderBuilder(1, "0x3867393cC6EA7b0414C2c3e1D9fe7cEa987Fd066")
+                .decayStartTime(TIMESTAMP_SECONDS)
+                .decayEndTime(TIMESTAMP_SECONDS)
+                .input({
+                token: WETH_MAINNET_CHECKSUMMED_ADDRESS,
+                startAmount: ethers_1.BigNumber.from(10).pow(18).mul(2),
+                endAmount: ethers_1.BigNumber.from(10).pow(18),
+            })
+                .output({
+                token: USDC_MAINNET_CHECKSUMMED_ADDRESS,
+                startAmount: ethers_1.BigNumber.from(10).pow(6).mul(3),
+                endAmount: ethers_1.BigNumber.from(10).pow(6).mul(2),
+                recipient: FROM_ADDRESS,
+            })
+                .nonce(ethers_1.BigNumber.from(1))
+                .deadline(Math.floor(Date.now() / 1000 + 600))
+                .swapper(FROM_ADDRESS)
+                .inputOverride(ethers_1.BigNumber.from(10).pow(18).mul(2))
+                .outputOverrides([ethers_1.BigNumber.from(10).pow(6).mul(3)])
+                .exclusivityOverrideBps(ethers_1.BigNumber.from(0))
+                .cosigner("0x0000000000000000000000000000000000000000")
+                .cosignature("0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+                .cosignerData({
+                decayStartTime: TIMESTAMP_SECONDS,
+                decayEndTime: TIMESTAMP_SECONDS,
+                exclusiveFiller: "0x0000000000000000000000000000000000000000",
+                exclusivityOverrideBps: ethers_1.BigNumber.from(0),
+                inputOverride: ethers_1.BigNumber.from(10).pow(18).mul(2),
+                outputOverrides: [ethers_1.BigNumber.from(10).pow(6).mul(3)],
+            })
+                .build()
+                .serialize();
+            //Missing configuration for reactor: 0xabcd111111111111111111111111111111111111 (swapper)
+            expect(uniswapXOrderParser.parseOrder(ENCODED_DUTCH_V2_ORDER, 1)).toEqual(order_1.CosignedV2DutchOrder.parse(ENCODED_DUTCH_V2_ORDER, 1));
+        });
         it("parses DutchOrder with multiple outputs", () => {
@@ -132,0 +172,0 @@ dutchOrder.info.outputs.push({

package.json

 {
   "name": "@uniswap/uniswapx-sdk",
   "author": "Uniswap",
-  "version": "2.0.1-alpha.2",
+  "version": "2.0.1-alpha.3",
   "license": "MIT",
@@ -6,0 +6,0 @@ "main": "dist/src/index.js",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1448278

increased by0.38%

Lines of code

19126

increased by0.27%

No dependency changes