@1inch/fusion-sdk 2.3.4 → 2.3.6-rc.0

package/dist/esm/fusion-order/fusion-order.js

@@ -1,38 +1,123 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 import { Address, Interaction, LimitOrder, MakerTraits } from '@1inch/limit-order-sdk';
 import assert from 'assert';
-import { FusionExtension } from './fusion-extension';
-import { injectTrackCode } from './source-track';
-import { SurplusParams } from './surplus-params';
-import { AuctionCalculator } from '../amount-calculator/auction-calculator';
-import { ZX } from '../constants';
-import { calcTakingAmount } from '../utils/amounts';
-import { now } from '../utils/time';
-import { AmountCalculator } from '../amount-calculator/amount-calculator';
-export class FusionOrder {
-    constructor(settlementExtensionContract, orderInfo, auctionDetails, whitelist, surplusParams = SurplusParams.NO_FEE, extra = FusionOrder.defaultExtra, extension = new FusionExtension(settlementExtensionContract, auctionDetails, whitelist, surplusParams, {
-        makerPermit: extra.permit
-            ? new Interaction(orderInfo.makerAsset, extra.permit)
-            : undefined,
-        customReceiver: orderInfo.receiver,
-        fees: extra?.fees
-    })) {
+import { FusionExtension } from './fusion-extension.js';
+import { injectTrackCode } from './source-track.js';
+import { SurplusParams } from './surplus-params.js';
+import { AuctionCalculator } from '../amount-calculator/auction-calculator/index.js';
+import { ZX } from '../constants.js';
+import { calcTakingAmount } from '../utils/amounts.js';
+import { now } from '../utils/time.js';
+import { AmountCalculator } from '../amount-calculator/amount-calculator.js';
+export var FusionOrder = /*#__PURE__*/ function() {
+    "use strict";
+    function FusionOrder(/**
+         * Fusion extension address
+         * @see https://github.com/1inch/limit-order-settlement
+         */ settlementExtensionContract, orderInfo, auctionDetails, whitelist) {
+        var surplusParams = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : SurplusParams.NO_FEE, extra = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : /**
+             * Required if `allowPartialFills` or `allowMultipleFills` is false
+             */ /**
+             * 0x prefixed without the token address
+             */ /**
+             * Default is true
+             */ /**
+             * Default is true
+             */ /**
+             * Order will expire in `orderExpirationDelay` after auction ends
+             * Default 12s
+             */ FusionOrder.defaultExtra, extension = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : new FusionExtension(settlementExtensionContract, auctionDetails, whitelist, surplusParams, {
+            makerPermit: extra.permit ? new Interaction(orderInfo.makerAsset, extra.permit) : undefined,
+            customReceiver: orderInfo.receiver,
+            fees: extra === null || extra === void 0 ? void 0 : extra.fees
+        });
+        _class_call_check(this, FusionOrder);
+        _define_property(this, "settlementExtensionContract", void 0);
+        _define_property(this, "fusionExtension", void 0);
+        _define_property(this, "inner", void 0);
         this.settlementExtensionContract = settlementExtensionContract;
-        const allowPartialFills = extra.allowPartialFills ??
-            FusionOrder.defaultExtra.allowPartialFills;
-        const allowMultipleFills = extra.allowMultipleFills ??
-            FusionOrder.defaultExtra.allowMultipleFills;
-        const unwrapWETH = extra.unwrapWETH ?? FusionOrder.defaultExtra.unwrapWETH;
-        const enablePermit2 = extra.enablePermit2 ?? FusionOrder.defaultExtra.enablePermit2;
-        const orderExpirationDelay = extra.orderExpirationDelay ??
-            FusionOrder.defaultExtra.orderExpirationDelay;
-        const deadline = auctionDetails.startTime +
-            auctionDetails.duration +
-            orderExpirationDelay;
-        const makerTraits = MakerTraits.default()
-            .withExpiration(deadline)
-            .setPartialFills(allowPartialFills)
-            .setMultipleFills(allowMultipleFills)
-            .enablePostInteraction();
+        var _extra_allowPartialFills;
+        var allowPartialFills = (_extra_allowPartialFills = extra.allowPartialFills) !== null && _extra_allowPartialFills !== void 0 ? _extra_allowPartialFills : FusionOrder.defaultExtra.allowPartialFills;
+        var _extra_allowMultipleFills;
+        var allowMultipleFills = (_extra_allowMultipleFills = extra.allowMultipleFills) !== null && _extra_allowMultipleFills !== void 0 ? _extra_allowMultipleFills : FusionOrder.defaultExtra.allowMultipleFills;
+        var _extra_unwrapWETH;
+        var unwrapWETH = (_extra_unwrapWETH = extra.unwrapWETH) !== null && _extra_unwrapWETH !== void 0 ? _extra_unwrapWETH : FusionOrder.defaultExtra.unwrapWETH;
+        var _extra_enablePermit2;
+        var enablePermit2 = (_extra_enablePermit2 = extra.enablePermit2) !== null && _extra_enablePermit2 !== void 0 ? _extra_enablePermit2 : FusionOrder.defaultExtra.enablePermit2;
+        var _extra_orderExpirationDelay;
+        var orderExpirationDelay = (_extra_orderExpirationDelay = extra.orderExpirationDelay) !== null && _extra_orderExpirationDelay !== void 0 ? _extra_orderExpirationDelay : FusionOrder.defaultExtra.orderExpirationDelay;
+        var deadline = auctionDetails.startTime + auctionDetails.duration + orderExpirationDelay;
+        var makerTraits = MakerTraits.default().withExpiration(deadline).setPartialFills(allowPartialFills).setMultipleFills(allowMultipleFills).enablePostInteraction();
         if (makerTraits.isBitInvalidatorMode()) {
             assert(extra.nonce !== undefined, 'Nonce required, when partial fill or multiple fill disallowed');
         }
@@ -45,171 +130,379 @@ export class FusionOrder {
         if (extra.nonce !== undefined) {
             makerTraits.withNonce(extra.nonce);
         }
-        const receiver = extra.fees || !surplusParams.isZero()
-            ? settlementExtensionContract
-            : orderInfo.receiver;
-        const builtExtension = extension.build();
-        const salt = LimitOrder.buildSalt(builtExtension, orderInfo.salt);
-        const saltWithInjectedTrackCode = orderInfo.salt
-            ? salt
-            : injectTrackCode(salt, extra.source);
-        this.inner = new LimitOrder({
-            ...orderInfo,
-            receiver,
+        /**
+         * @see https://github.com/1inch/limit-order-settlement/blob/0afb4785cb825fe959c534ff4f1a771d4d33cdf4/contracts/extensions/IntegratorFeeExtension.sol#L65
+         */ var receiver = extra.fees || !surplusParams.isZero() ? settlementExtensionContract : orderInfo.receiver;
+        var builtExtension = extension.build();
+        var salt = LimitOrder.buildSalt(builtExtension, orderInfo.salt);
+        var saltWithInjectedTrackCode = orderInfo.salt ? salt : injectTrackCode(salt, extra.source);
+        this.inner = new LimitOrder(_object_spread_props(_object_spread({}, orderInfo), {
+            receiver: receiver,
             salt: saltWithInjectedTrackCode
-        }, makerTraits, builtExtension);
+        }), makerTraits, builtExtension);
         this.fusionExtension = extension;
     }
-    get extension() {
-        return this.inner.extension;
-    }
-    get maker() {
-        return this.inner.maker;
-    }
-    get takerAsset() {
-        return this.inner.takerAsset;
-    }
-    get makerAsset() {
-        return this.inner.makerAsset;
-    }
-    get takingAmount() {
-        return this.inner.takingAmount;
-    }
-    get makingAmount() {
-        return this.inner.makingAmount;
-    }
-    get realReceiver() {
-        const hasFee = Boolean(this.fusionExtension.extra?.fees);
-        const receiver = hasFee
-            ? this.fusionExtension.extra?.customReceiver
-            : this.inner.receiver;
-        return receiver && !receiver.isZero() ? receiver : this.maker;
-    }
-    get receiver() {
-        return this.inner.receiver;
-    }
-    get deadline() {
-        return this.inner.makerTraits.expiration() || 0n;
-    }
-    get auctionStartTime() {
-        return this.fusionExtension.auctionDetails.startTime;
-    }
-    get auctionEndTime() {
-        const { startTime, duration } = this.fusionExtension.auctionDetails;
-        return startTime + duration;
-    }
-    get isBitInvalidatorMode() {
-        return this.inner.makerTraits.isBitInvalidatorMode();
-    }
-    get partialFillAllowed() {
-        return this.inner.makerTraits.isPartialFillAllowed();
-    }
-    get multipleFillsAllowed() {
-        return this.inner.makerTraits.isMultipleFillsAllowed();
-    }
-    get nonce() {
-        return this.inner.makerTraits.nonceOrEpoch();
-    }
-    get salt() {
-        return this.inner.salt;
-    }
-    static new(settlementExtension, orderInfo, details, extra) {
-        return new FusionOrder(settlementExtension, orderInfo, details.auction, details.whitelist, details.surplus, extra);
-    }
-    static fromDataAndExtension(order, extension) {
-        const settlementContract = Address.fromFirstBytes(extension.makingAmountData);
-        assert(Address.fromFirstBytes(extension.takingAmountData).equal(settlementContract) &&
-            Address.fromFirstBytes(extension.postInteraction).equal(settlementContract), 'Invalid extension, all calls should be to the same address');
-        const makerTraits = new MakerTraits(BigInt(order.makerTraits));
-        assert(!makerTraits.isPrivate(), 'fusion order can not be private');
-        assert(makerTraits.hasPostInteraction(), 'post-interaction must be enabled');
-        const { auctionDetails, whitelist, extra, surplus } = FusionExtension.fromExtension(extension);
-        const deadline = makerTraits.expiration();
-        const orderExpirationDelay = deadline === null
-            ? undefined
-            : deadline - auctionDetails.startTime - auctionDetails.duration;
-        return new FusionOrder(settlementContract, {
-            salt: BigInt(order.salt) >> 160n,
-            maker: new Address(order.maker),
-            receiver: extra?.customReceiver,
-            makerAsset: new Address(order.makerAsset),
-            takerAsset: new Address(order.takerAsset),
-            makingAmount: BigInt(order.makingAmount),
-            takingAmount: BigInt(order.takingAmount)
-        }, auctionDetails, whitelist, surplus, {
-            allowMultipleFills: makerTraits.isMultipleFillsAllowed(),
-            allowPartialFills: makerTraits.isPartialFillAllowed(),
-            enablePermit2: makerTraits.isPermit2(),
-            nonce: makerTraits.nonceOrEpoch(),
-            permit: extension.makerPermit === ZX
-                ? undefined
-                : Interaction.decode(extension.makerPermit).data,
-            unwrapWETH: makerTraits.isNativeUnwrapEnabled(),
-            orderExpirationDelay,
-            fees: extra?.fees
-        });
-    }
-    build() {
-        return this.inner.build();
-    }
-    getOrderHash(chainId) {
-        return this.inner.getOrderHash(chainId);
-    }
-    getTypedData(chainId) {
-        return this.inner.getTypedData(chainId);
-    }
-    getCalculator() {
-        return AuctionCalculator.fromAuctionData(this.fusionExtension.auctionDetails);
-    }
-    calcTakingAmount(taker, makingAmount, time, blockBaseFee = 0n) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return this.getAmountCalculator().getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee);
-    }
-    getUserReceiveAmount(taker, makingAmount, time, blockBaseFee = 0n) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return this.getAmountCalculator().getUserTakingAmount(taker, makingAmount, takingAmount, this.makingAmount, time, blockBaseFee);
-    }
-    getSurplusFee(taker, makingAmount, time, blockBaseFee = 0n) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return this.getAmountCalculator().getSurplusFee(taker, makingAmount, takingAmount, this.makingAmount, time, blockBaseFee);
-    }
-    getResolverFee(taker, time, blockBaseFee = 0n, makingAmount = this.makingAmount) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return (this.getAmountCalculator().getResolverFee(taker, takingAmount, time, blockBaseFee) ?? 0n);
-    }
-    getIntegratorFee(taker, time, blockBaseFee = 0n, makingAmount = this.makingAmount) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return (this.getAmountCalculator().getIntegratorFee(taker, takingAmount, time, blockBaseFee) ?? 0n);
-    }
-    getProtocolShareOfIntegratorFee(taker, time, blockBaseFee = 0n, makingAmount = this.makingAmount) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return (this.getAmountCalculator().getProtocolShareOfIntegratorFee(taker, takingAmount, time, blockBaseFee) ?? 0n);
-    }
-    getProtocolFee(taker, time, blockBaseFee = 0n, makingAmount = this.makingAmount) {
-        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
-        return (this.getAmountCalculator().getProtocolFee(taker, takingAmount, time, blockBaseFee) ?? 0n);
-    }
-    canExecuteAt(executor, executionTime) {
-        return this.fusionExtension.whitelist.canExecuteAt(executor, executionTime);
-    }
-    isExpiredAt(time) {
-        return time > this.deadline;
-    }
-    isExclusiveResolver(wallet) {
-        return this.fusionExtension.whitelist.isExclusiveResolver(wallet);
-    }
-    isExclusivityPeriod(time = now()) {
-        return this.fusionExtension.whitelist.isExclusivityPeriod(time);
-    }
-    getAmountCalculator() {
-        return AmountCalculator.fromExtension(this.fusionExtension);
-    }
-}
-FusionOrder.defaultExtra = {
+    _create_class(FusionOrder, [
+        {
+            key: "extension",
+            get: function get() {
+                return this.inner.extension;
+            }
+        },
+        {
+            key: "maker",
+            get: function get() {
+                return this.inner.maker;
+            }
+        },
+        {
+            key: "takerAsset",
+            get: function get() {
+                return this.inner.takerAsset;
+            }
+        },
+        {
+            key: "makerAsset",
+            get: function get() {
+                return this.inner.makerAsset;
+            }
+        },
+        {
+            key: "takingAmount",
+            get: function get() {
+                return this.inner.takingAmount;
+            }
+        },
+        {
+            key: "makingAmount",
+            get: function get() {
+                return this.inner.makingAmount;
+            }
+        },
+        {
+            key: "realReceiver",
+            get: /**
+     * Returns actual receiver of funds
+     *
+     * Do not use this field to pass to order struct as it can lead to lost of funds
+     * For such cases use `order.receiver`
+     *
+     * @see receiver
+     */ function get() {
+                var _this_fusionExtension_extra, _this_fusionExtension_extra1;
+                var hasFee = Boolean((_this_fusionExtension_extra = this.fusionExtension.extra) === null || _this_fusionExtension_extra === void 0 ? void 0 : _this_fusionExtension_extra.fees);
+                var receiver = hasFee ? (_this_fusionExtension_extra1 = this.fusionExtension.extra) === null || _this_fusionExtension_extra1 === void 0 ? void 0 : _this_fusionExtension_extra1.customReceiver : this.inner.receiver;
+                return receiver && !receiver.isZero() ? receiver : this.maker;
+            }
+        },
+        {
+            key: "receiver",
+            get: /**
+     * Receiver from order struct
+     *
+     * @see realReceiver
+     */ function get() {
+                return this.inner.receiver;
+            }
+        },
+        {
+            key: "deadline",
+            get: /**
+     * Timestamp in sec
+     */ function get() {
+                return this.inner.makerTraits.expiration() || 0n;
+            }
+        },
+        {
+            key: "auctionStartTime",
+            get: /**
+     * Timestamp in sec
+     */ function get() {
+                return this.fusionExtension.auctionDetails.startTime;
+            }
+        },
+        {
+            key: "auctionEndTime",
+            get: /**
+     * Timestamp in sec
+     */ function get() {
+                var _this_fusionExtension_auctionDetails = this.fusionExtension.auctionDetails, startTime = _this_fusionExtension_auctionDetails.startTime, duration = _this_fusionExtension_auctionDetails.duration;
+                return startTime + duration;
+            }
+        },
+        {
+            key: "isBitInvalidatorMode",
+            get: function get() {
+                return this.inner.makerTraits.isBitInvalidatorMode();
+            }
+        },
+        {
+            key: "partialFillAllowed",
+            get: function get() {
+                return this.inner.makerTraits.isPartialFillAllowed();
+            }
+        },
+        {
+            key: "multipleFillsAllowed",
+            get: function get() {
+                return this.inner.makerTraits.isMultipleFillsAllowed();
+            }
+        },
+        {
+            key: "nonce",
+            get: function get() {
+                return this.inner.makerTraits.nonceOrEpoch();
+            }
+        },
+        {
+            key: "salt",
+            get: function get() {
+                return this.inner.salt;
+            }
+        },
+        {
+            key: "build",
+            value: function build() {
+                return this.inner.build();
+            }
+        },
+        {
+            key: "getOrderHash",
+            value: function getOrderHash(chainId) {
+                return this.inner.getOrderHash(chainId);
+            }
+        },
+        {
+            key: "getTypedData",
+            value: function getTypedData(chainId) {
+                return this.inner.getTypedData(chainId);
+            }
+        },
+        {
+            key: "getCalculator",
+            value: function getCalculator() {
+                return AuctionCalculator.fromAuctionData(this.fusionExtension.auctionDetails);
+            }
+        },
+        {
+            key: "calcTakingAmount",
+            value: /**
+     * Calculates required taking amount for passed `makingAmount` at block time `time`
+     *
+     * @param taker address who fill order
+     * @param time execution time in sec
+     * @param blockBaseFee block fee in wei.
+     * @param makingAmount maker swap amount
+     * */ function calcTakingAmount1(taker, makingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                return this.getAmountCalculator().getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee);
+            }
+        },
+        {
+            key: "getUserReceiveAmount",
+            value: /**
+     * How much user will receive in taker asset
+     *
+     * @param taker who will fill order
+     * @param makingAmount maker swap amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getUserReceiveAmount(taker, makingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                return this.getAmountCalculator().getUserTakingAmount(taker, makingAmount, takingAmount, this.makingAmount, time, blockBaseFee);
+            }
+        },
+        {
+            key: "getSurplusFee",
+            value: /**
+     * How much surplus will be shared with protocol
+     *
+     * @param taker who will fill order
+     * @param makingAmount maker swap amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getSurplusFee(taker, makingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                return this.getAmountCalculator().getSurplusFee(taker, makingAmount, takingAmount, this.makingAmount, time, blockBaseFee);
+            }
+        },
+        {
+            key: "getResolverFee",
+            value: /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param makingAmount maker swap amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getResolverFee(taker, time) {
+                var blockBaseFee = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0n, makingAmount = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : this.makingAmount;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                var _this_getAmountCalculator_getResolverFee;
+                return (_this_getAmountCalculator_getResolverFee = this.getAmountCalculator().getResolverFee(taker, takingAmount, time, blockBaseFee)) !== null && _this_getAmountCalculator_getResolverFee !== void 0 ? _this_getAmountCalculator_getResolverFee : 0n;
+            }
+        },
+        {
+            key: "getIntegratorFee",
+            value: /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param makingAmount maker swap amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getIntegratorFee(taker, time) {
+                var blockBaseFee = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0n, makingAmount = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : this.makingAmount;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                var _this_getAmountCalculator_getIntegratorFee;
+                return (_this_getAmountCalculator_getIntegratorFee = this.getAmountCalculator().getIntegratorFee(taker, takingAmount, time, blockBaseFee)) !== null && _this_getAmountCalculator_getIntegratorFee !== void 0 ? _this_getAmountCalculator_getIntegratorFee : 0n;
+            }
+        },
+        {
+            key: "getProtocolShareOfIntegratorFee",
+            value: /**
+     * Fee in `takerAsset` which protocol gets as share from integrator fee
+     *
+     * @param taker who will fill order
+     * @param makingAmount maker swap amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getProtocolShareOfIntegratorFee(taker, time) {
+                var blockBaseFee = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0n, makingAmount = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : this.makingAmount;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                var _this_getAmountCalculator_getProtocolShareOfIntegratorFee;
+                return (_this_getAmountCalculator_getProtocolShareOfIntegratorFee = this.getAmountCalculator().getProtocolShareOfIntegratorFee(taker, takingAmount, time, blockBaseFee)) !== null && _this_getAmountCalculator_getProtocolShareOfIntegratorFee !== void 0 ? _this_getAmountCalculator_getProtocolShareOfIntegratorFee : 0n;
+            }
+        },
+        {
+            key: "getProtocolFee",
+            value: /**
+     * Fee in `takerAsset` which protocol gets
+     * It equals to `share from integrator fee plus resolver fee`
+     *
+     * @param taker who will fill order
+     * @param makingAmount maker swap amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getProtocolFee(taker, time) {
+                var blockBaseFee = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0n, makingAmount = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : this.makingAmount;
+                var takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+                var _this_getAmountCalculator_getProtocolFee;
+                return (_this_getAmountCalculator_getProtocolFee = this.getAmountCalculator().getProtocolFee(taker, takingAmount, time, blockBaseFee)) !== null && _this_getAmountCalculator_getProtocolFee !== void 0 ? _this_getAmountCalculator_getProtocolFee : 0n;
+            }
+        },
+        {
+            key: "canExecuteAt",
+            value: /**
+     * Check whether address allowed to execute order at the given time
+     *
+     * @param executor address of executor
+     * @param executionTime timestamp in sec at which order planning to execute
+     */ function canExecuteAt(executor, executionTime) {
+                return this.fusionExtension.whitelist.canExecuteAt(executor, executionTime);
+            }
+        },
+        {
+            key: "isExpiredAt",
+            value: /**
+     * Check is order expired at a given time
+     *
+     * @param time timestamp in seconds
+     */ function isExpiredAt(time) {
+                return time > this.deadline;
+            }
+        },
+        {
+            key: "isExclusiveResolver",
+            value: /**
+     * Check if `wallet` can fill order before other
+     */ function isExclusiveResolver(wallet) {
+                return this.fusionExtension.whitelist.isExclusiveResolver(wallet);
+            }
+        },
+        {
+            key: "isExclusivityPeriod",
+            value: /**
+     * Check if the auction has exclusive resolver, and it is in the exclusivity period
+     */ function isExclusivityPeriod() {
+                var time = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : now();
+                return this.fusionExtension.whitelist.isExclusivityPeriod(time);
+            }
+        },
+        {
+            key: "getAmountCalculator",
+            value: function getAmountCalculator() {
+                return AmountCalculator.fromExtension(this.fusionExtension);
+            }
+        }
+    ], [
+        {
+            key: "new",
+            value: function _new(/**
+         * Fusion extension address
+         * @see https://github.com/1inch/limit-order-settlement
+         */ settlementExtension, orderInfo, details, extra) /**
+             * Required if `allowPartialFills` or `allowMultipleFills` is false
+             * Max size is 40bit
+             */ /**
+             * Default is true
+             */ /**
+             * Default is true
+             */ /**
+             * Order will expire in `orderExpirationDelay` after auction ends
+             * Default 12s
+             */ {
+                return new FusionOrder(settlementExtension, orderInfo, details.auction, details.whitelist, details.surplus, extra);
+            }
+        },
+        {
+            key: "fromDataAndExtension",
+            value: /**
+     * Create FusionOrder from order data and extension
+     *
+     */ function fromDataAndExtension(order, extension) {
+                var settlementContract = Address.fromFirstBytes(extension.makingAmountData);
+                assert(Address.fromFirstBytes(extension.takingAmountData).equal(settlementContract) && Address.fromFirstBytes(extension.postInteraction).equal(settlementContract), 'Invalid extension, all calls should be to the same address');
+                var makerTraits = new MakerTraits(BigInt(order.makerTraits));
+                assert(!makerTraits.isPrivate(), 'fusion order can not be private');
+                assert(makerTraits.hasPostInteraction(), 'post-interaction must be enabled');
+                var _FusionExtension_fromExtension = FusionExtension.fromExtension(extension), auctionDetails = _FusionExtension_fromExtension.auctionDetails, whitelist = _FusionExtension_fromExtension.whitelist, extra = _FusionExtension_fromExtension.extra, surplus = _FusionExtension_fromExtension.surplus;
+                var deadline = makerTraits.expiration();
+                var orderExpirationDelay = deadline === null ? undefined : deadline - auctionDetails.startTime - auctionDetails.duration;
+                var providedSalt = BigInt(order.salt);
+                var fusionOrder = new FusionOrder(settlementContract, {
+                    // shift because of how LimitOrder.buildSalt works
+                    salt: providedSalt >> 160n,
+                    maker: new Address(order.maker),
+                    receiver: extra === null || extra === void 0 ? void 0 : extra.customReceiver,
+                    makerAsset: new Address(order.makerAsset),
+                    takerAsset: new Address(order.takerAsset),
+                    makingAmount: BigInt(order.makingAmount),
+                    takingAmount: BigInt(order.takingAmount)
+                }, auctionDetails, whitelist, surplus, {
+                    allowMultipleFills: makerTraits.isMultipleFillsAllowed(),
+                    allowPartialFills: makerTraits.isPartialFillAllowed(),
+                    enablePermit2: makerTraits.isPermit2(),
+                    nonce: makerTraits.nonceOrEpoch(),
+                    permit: extension.makerPermit === ZX ? undefined : Interaction.decode(extension.makerPermit).data,
+                    unwrapWETH: makerTraits.isNativeUnwrapEnabled(),
+                    orderExpirationDelay: orderExpirationDelay,
+                    fees: extra === null || extra === void 0 ? void 0 : extra.fees
+                });
+                assert(providedSalt === fusionOrder.salt, 'invalid salt for passed extension');
+                return fusionOrder;
+            }
+        }
+    ]);
+    return FusionOrder;
+}();
+_define_property(FusionOrder, "defaultExtra", {
     allowPartialFills: true,
     allowMultipleFills: true,
     unwrapWETH: false,
     enablePermit2: false,
     orderExpirationDelay: 12n
-};
-//# sourceMappingURL=fusion-order.js.map
+});