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

package/dist/cjs/amount-calculator/amount-calculator.js

@@ -1,85 +1,281 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmountCalculator = void 0;
-const limit_order_sdk_1 = require("@1inch/limit-order-sdk");
-const fee_taker_1 = require("@1inch/limit-order-sdk/extensions/fee-taker");
-const auction_calculator_1 = require("./auction-calculator");
-const fusion_order_1 = require("../fusion-order");
-class AmountCalculator {
-    constructor(auctionCalculator, feeCalculator, surplus = fusion_order_1.SurplusParams.NO_FEE) {
-        this.auctionCalculator = auctionCalculator;
-        this.feeCalculator = feeCalculator;
-        this.surplus = surplus;
-    }
-    static fromExtension(ext) {
-        return new AmountCalculator(auction_calculator_1.AuctionCalculator.fromAuctionData(ext.auctionDetails), ext.extra?.fees
-            ? new limit_order_sdk_1.FeeTakerExt.FeeCalculator(ext.extra?.fees, ext.whitelist)
-            : undefined, ext.surplus);
-    }
-    static calcAuctionTakingAmount(baseTakingAmount, rate, fee = limit_order_sdk_1.Bps.ZERO) {
-        const withoutFee = auction_calculator_1.AuctionCalculator.calcAuctionTakingAmount(baseTakingAmount, rate);
-        if (fee.isZero()) {
-            return withoutFee;
-        }
-        const numerator = fee_taker_1.Fees.BASE_1E5 + BigInt(fee.toFraction(fee_taker_1.Fees.BASE_1E5));
-        return (withoutFee * numerator) / fee_taker_1.Fees.BASE_1E5;
-    }
-    static extractFeeAmount(requiredTakingAmount, fee) {
-        return (requiredTakingAmount -
-            (0, limit_order_sdk_1.mulDiv)(requiredTakingAmount, fee_taker_1.Fees.BASE_1E5, fee_taker_1.Fees.BASE_1E5 + BigInt(fee.toFraction(fee_taker_1.Fees.BASE_1E5)), limit_order_sdk_1.Rounding.Ceil));
-    }
-    getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee = 0n) {
-        const withFee = this.feeCalculator?.getTakingAmount(taker, takingAmount) ??
-            takingAmount;
-        return this.getAuctionBumpedAmount(withFee, time, blockBaseFee);
-    }
-    getRequiredMakingAmount(taker, makingAmount, time, blockBaseFee = 0n) {
-        const withFee = this.feeCalculator?.getMakingAmount(taker, makingAmount) ??
-            makingAmount;
-        const rateBump = this.auctionCalculator.calcRateBump(time, blockBaseFee);
-        return auction_calculator_1.AuctionCalculator.calcAuctionMakingAmount(withFee, rateBump);
-    }
-    getTotalFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.getIntegratorFee(taker, takingAmount, time, blockBaseFee) +
-            this.getProtocolFee(taker, takingAmount, time, blockBaseFee));
-    }
-    getUserTakingAmount(taker, makingAmount, takingAmount, orderMakingAmount, time, blockBaseFee = 0n) {
-        const whole = this.getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee);
-        const preSurplus = whole - this.getTotalFee(taker, takingAmount, time, blockBaseFee);
-        const surplusFee = this._getSurplusFee(preSurplus, makingAmount, orderMakingAmount);
-        return preSurplus - surplusFee;
-    }
-    getSurplusFee(taker, makingAmount, takingAmount, orderMakingAmount, time, blockBaseFee = 0n) {
-        const whole = this.getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee);
-        const preSurplus = whole - this.getTotalFee(taker, takingAmount, time, blockBaseFee);
-        return this._getSurplusFee(preSurplus, makingAmount, orderMakingAmount);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AmountCalculator", {
+    enumerable: true,
+    get: function() {
+        return AmountCalculator;
     }
-    getResolverFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getResolverFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
+});
+var _limitordersdk = require("@1inch/limit-order-sdk");
+var _index = require("./auction-calculator/index.js");
+var _index1 = require("../fusion-order/index.js");
+var _index2 = require("../fusion-order/fees/index.js");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    getIntegratorFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getIntegratorFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
+}
+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);
     }
-    getProtocolShareOfIntegratorFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getProtocolShareOfIntegratorFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
+}
+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;
     }
-    getProtocolFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getProtocolFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
+    return obj;
+}
+/**
+ * Calculates fees/amount with accounting to auction
+ *
+ * @see FusionOrder
+ */ var AmountCalculator = /*#__PURE__*/ function() {
+    "use strict";
+    function AmountCalculator(auctionCalculator, feeCalculator) {
+        var surplus = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _index1.SurplusParams.NO_FEE;
+        _class_call_check(this, AmountCalculator);
+        _define_property(this, "auctionCalculator", void 0);
+        _define_property(this, "feeCalculator", void 0);
+        _define_property(this, "surplus", void 0);
+        this.auctionCalculator = auctionCalculator;
+        this.feeCalculator = feeCalculator;
+        this.surplus = surplus;
     }
-    _getSurplusFee(userTakingAmount, makingAmount, orderMakingAmount) {
-        const estimatedTakingAmount = (0, limit_order_sdk_1.mulDiv)(this.surplus.estimatedTakerAmount, makingAmount, orderMakingAmount);
-        if (userTakingAmount > estimatedTakingAmount) {
-            const surplusFee = ((userTakingAmount - estimatedTakingAmount) *
-                BigInt(this.surplus.protocolFee.toPercent())) /
-                100n;
-            return surplusFee;
+    _create_class(AmountCalculator, [
+        {
+            key: "getRequiredTakingAmount",
+            value: /**
+     * Returns adjusted taking amount with included fees and auction bump
+     *
+     * @param taker address which fill order
+     * @param takingAmount base taking amount without auction and fee
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getRequiredTakingAmount(taker, takingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var _this_feeCalculator;
+                var _this_feeCalculator_getTakingAmount;
+                var withFee = (_this_feeCalculator_getTakingAmount = (_this_feeCalculator = this.feeCalculator) === null || _this_feeCalculator === void 0 ? void 0 : _this_feeCalculator.getTakingAmount(taker, takingAmount)) !== null && _this_feeCalculator_getTakingAmount !== void 0 ? _this_feeCalculator_getTakingAmount : takingAmount;
+                return this.getAuctionBumpedAmount(withFee, time, blockBaseFee);
+            }
+        },
+        {
+            key: "getRequiredMakingAmount",
+            value: /**
+     * Returns adjusted making amount with accounting of fees and auction bump
+     *
+     * @param taker address which fill order
+     * @param makingAmount base making amount without auction and fee
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getRequiredMakingAmount(taker, makingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var _this_feeCalculator;
+                var _this_feeCalculator_getMakingAmount;
+                var withFee = (_this_feeCalculator_getMakingAmount = (_this_feeCalculator = this.feeCalculator) === null || _this_feeCalculator === void 0 ? void 0 : _this_feeCalculator.getMakingAmount(taker, makingAmount)) !== null && _this_feeCalculator_getMakingAmount !== void 0 ? _this_feeCalculator_getMakingAmount : makingAmount;
+                var rateBump = this.auctionCalculator.calcRateBump(time, blockBaseFee);
+                return _index.AuctionCalculator.calcAuctionMakingAmount(withFee, rateBump);
+            }
+        },
+        {
+            key: "getTotalFee",
+            value: /**
+     * Returns total fee = integrator + protocol
+     *
+     * @param taker
+     * @param takingAmount base taking amount without auction and fee
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getTotalFee(taker, takingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                return this.getIntegratorFee(taker, takingAmount, time, blockBaseFee) + this.getProtocolFee(taker, takingAmount, time, blockBaseFee);
+            }
+        },
+        {
+            key: "getUserTakingAmount",
+            value: /**
+     * Returns amount which will receive user
+     *
+     * @param taker
+     * @param makingAmount amount to be filled
+     * @param takingAmount base taking amount without auction and fee
+     * @param orderMakingAmount full order making amount
+     * @param time block time at which order will be filled
+     * @param blockBaseFee base fee of block at which order will be filled
+     */ function getUserTakingAmount(taker, makingAmount, takingAmount, orderMakingAmount, time) {
+                var blockBaseFee = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0n;
+                var whole = this.getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee);
+                var preSurplus = whole - this.getTotalFee(taker, takingAmount, time, blockBaseFee);
+                var surplusFee = this._getSurplusFee(preSurplus, makingAmount, orderMakingAmount);
+                return preSurplus - surplusFee;
+            }
+        },
+        {
+            key: "getSurplusFee",
+            value: /**
+     * Returns amount in taker asset which sent to protocol as part of surplus share
+     *
+     * @param taker
+     * @param makingAmount amount to be filled
+     * @param takingAmount base taking amount without auction and fee
+     * @param orderMakingAmount full order making 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, takingAmount, orderMakingAmount, time) {
+                var blockBaseFee = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0n;
+                var whole = this.getRequiredTakingAmount(taker, takingAmount, time, blockBaseFee);
+                var preSurplus = whole - this.getTotalFee(taker, takingAmount, time, blockBaseFee);
+                return this._getSurplusFee(preSurplus, makingAmount, orderMakingAmount);
+            }
+        },
+        {
+            key: "getResolverFee",
+            value: /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to calculate fee from, must be without fees/auction adjustments
+     * @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, takingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var _this_feeCalculator;
+                var _this_feeCalculator_getResolverFee;
+                return (_this_feeCalculator_getResolverFee = (_this_feeCalculator = this.feeCalculator) === null || _this_feeCalculator === void 0 ? void 0 : _this_feeCalculator.getResolverFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee))) !== null && _this_feeCalculator_getResolverFee !== void 0 ? _this_feeCalculator_getResolverFee : 0n;
+            }
+        },
+        {
+            key: "getIntegratorFee",
+            value: /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to calculate fee from, must be without fees/auction adjustments
+     * @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, takingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var _this_feeCalculator;
+                var _this_feeCalculator_getIntegratorFee;
+                return (_this_feeCalculator_getIntegratorFee = (_this_feeCalculator = this.feeCalculator) === null || _this_feeCalculator === void 0 ? void 0 : _this_feeCalculator.getIntegratorFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee))) !== null && _this_feeCalculator_getIntegratorFee !== void 0 ? _this_feeCalculator_getIntegratorFee : 0n;
+            }
+        },
+        {
+            key: "getProtocolShareOfIntegratorFee",
+            value: /**
+     * Fee in `takerAsset` which protocol gets as share from integrator fee
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to calculate fee from, must be without fees/auction adjustments
+     * @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, takingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var _this_feeCalculator;
+                var _this_feeCalculator_getProtocolShareOfIntegratorFee;
+                return (_this_feeCalculator_getProtocolShareOfIntegratorFee = (_this_feeCalculator = this.feeCalculator) === null || _this_feeCalculator === void 0 ? void 0 : _this_feeCalculator.getProtocolShareOfIntegratorFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee))) !== null && _this_feeCalculator_getProtocolShareOfIntegratorFee !== void 0 ? _this_feeCalculator_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 takingAmount taking amount to calculate fee from, must be without fees/auction adjustments
+     * @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, takingAmount, time) {
+                var blockBaseFee = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0n;
+                var _this_feeCalculator;
+                var _this_feeCalculator_getProtocolFee;
+                return (_this_feeCalculator_getProtocolFee = (_this_feeCalculator = this.feeCalculator) === null || _this_feeCalculator === void 0 ? void 0 : _this_feeCalculator.getProtocolFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee))) !== null && _this_feeCalculator_getProtocolFee !== void 0 ? _this_feeCalculator_getProtocolFee : 0n;
+            }
+        },
+        {
+            key: "_getSurplusFee",
+            value: /**
+     * Calculates surplus fee. It will be sent to the same address as `protocolFee`
+     *
+     * @param userTakingAmount how much user would receive without surplus
+     * @param makingAmount making amount to be filled
+     * @param orderMakingAmount full order making amount
+     */ function _getSurplusFee(userTakingAmount, makingAmount, orderMakingAmount) {
+                var estimatedTakingAmount = (0, _limitordersdk.mulDiv)(this.surplus.estimatedTakerAmount, makingAmount, orderMakingAmount);
+                if (userTakingAmount > estimatedTakingAmount) {
+                    var surplusFee = (userTakingAmount - estimatedTakingAmount) * BigInt(this.surplus.protocolFee.toPercent()) / 100n;
+                    return surplusFee;
+                }
+                return 0n;
+            }
+        },
+        {
+            key: "getAuctionBumpedAmount",
+            value: function getAuctionBumpedAmount(takingAmount, time) {
+                var blockBaseFee = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0n;
+                var rateBump = this.auctionCalculator.calcRateBump(time, blockBaseFee);
+                return _index.AuctionCalculator.calcAuctionTakingAmount(takingAmount, rateBump);
+            }
         }
-        return 0n;
-    }
-    getAuctionBumpedAmount(takingAmount, time, blockBaseFee = 0n) {
-        const rateBump = this.auctionCalculator.calcRateBump(time, blockBaseFee);
-        return auction_calculator_1.AuctionCalculator.calcAuctionTakingAmount(takingAmount, rateBump);
-    }
-}
-exports.AmountCalculator = AmountCalculator;
-//# sourceMappingURL=amount-calculator.js.map
+    ], [
+        {
+            key: "fromExtension",
+            value: function fromExtension(ext) {
+                var _ext_extra, _ext_extra1;
+                return new AmountCalculator(_index.AuctionCalculator.fromAuctionData(ext.auctionDetails), ((_ext_extra = ext.extra) === null || _ext_extra === void 0 ? void 0 : _ext_extra.fees) ? new _limitordersdk.FeeTakerExt.FeeCalculator((_ext_extra1 = ext.extra) === null || _ext_extra1 === void 0 ? void 0 : _ext_extra1.fees, ext.whitelist) : undefined, ext.surplus);
+            }
+        },
+        {
+            key: "calcAuctionTakingAmount",
+            value: /**
+     * Returns amount with applied rate bump and fees
+     *
+     * @param baseTakingAmount base amount to apply bump to
+     * @param rate auction rate bump
+     * @param fee all fees applied to amount
+     *
+     * @see AuctionCalculator.calcInitialRateBump
+     */ function calcAuctionTakingAmount(baseTakingAmount, rate) {
+                var fee = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _limitordersdk.Bps.ZERO;
+                var withoutFee = _index.AuctionCalculator.calcAuctionTakingAmount(baseTakingAmount, rate);
+                if (fee.isZero()) {
+                    return withoutFee;
+                }
+                var numerator = _index2.Fees.BASE_1E5 + BigInt(fee.toFraction(_index2.Fees.BASE_1E5));
+                return withoutFee * numerator / _index2.Fees.BASE_1E5;
+            }
+        },
+        {
+            key: "extractFeeAmount",
+            value: /**
+     * Return fee amount in taker asset which is included in `requiredTakingAmount`
+     *
+     * @param requiredTakingAmount must already contain fee
+     * @param fee to extract
+     */ function extractFeeAmount(requiredTakingAmount, fee) {
+                return requiredTakingAmount - (0, _limitordersdk.mulDiv)(requiredTakingAmount, _index2.Fees.BASE_1E5, _index2.Fees.BASE_1E5 + BigInt(fee.toFraction(_index2.Fees.BASE_1E5)), _limitordersdk.Rounding.Ceil);
+            }
+        }
+    ]);
+    return AmountCalculator;
+}();

package/dist/cjs/amount-calculator/amount-calculator.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _limitordersdk = require("@1inch/limit-order-sdk");
+var _amountcalculator = require("./amount-calculator.js");
+var _index = require("./auction-calculator/index.js");
+var _index1 = require("../fusion-order/index.js");
+var _time = require("../utils/time.js");
+var _index2 = require("../fusion-order/fees/index.js");
+describe('AmountCalculator', function() {
+    it('should correct extract fee', function() {
+        var integratorFeeBps = new _limitordersdk.Bps(6n);
+        // 60% from 10bps
+        var calculator = new _amountcalculator.AmountCalculator(new _index.AuctionCalculator(1738650250n, 180n, 1218519n, [
+            {
+                coefficient: 609353,
+                delay: 180
+            }
+        ], {
+            gasBumpEstimate: 609353n,
+            gasPriceEstimate: 1526n
+        }), new _limitordersdk.FeeTakerExt.FeeCalculator(_index2.Fees.integratorFee(new _index2.IntegratorFee(new _limitordersdk.Address('0x8e097e5e0493de033270a01b324caf31f464dc67'), new _limitordersdk.Address('0x90cbe4bdd538d6e9b379bff5fe72c3d67a521de5'), new _limitordersdk.Bps(10n), new _limitordersdk.Bps(6000n))), _index1.Whitelist.new(1738650226n, [
+            {
+                address: _limitordersdk.Address.fromBigInt(1n),
+                allowFrom: 0n
+            }
+        ])));
+        var takingAmount = 100000n;
+        var requiredTakingAmount = calculator.getRequiredTakingAmount(_limitordersdk.Address.ZERO_ADDRESS, takingAmount, (0, _time.now)(), 10n);
+        var integratorFee = calculator.getIntegratorFee(_limitordersdk.Address.ZERO_ADDRESS, takingAmount, (0, _time.now)(), 10n);
+        expect(_amountcalculator.AmountCalculator.extractFeeAmount(requiredTakingAmount, integratorFeeBps)).toEqual(integratorFee);
+    });
+    it('should apply surplus', function() {
+        var startTime = 1738650250n;
+        var execTime = startTime + 180n;
+        // end of auction
+        var auction = new _index.AuctionCalculator(startTime, 180n, 1218519n, [
+            {
+                coefficient: 609353,
+                delay: 180
+            }
+        ], {
+            gasBumpEstimate: 609353n,
+            gasPriceEstimate: 1526n
+        });
+        var taker = _limitordersdk.Address.fromBigInt(1n);
+        var feeCalculator = new _limitordersdk.FeeTakerExt.FeeCalculator(_index2.Fees.integratorFee(new _index2.IntegratorFee(new _limitordersdk.Address('0x8e097e5e0493de033270a01b324caf31f464dc67'), new _limitordersdk.Address('0x90cbe4bdd538d6e9b379bff5fe72c3d67a521de5'), new _limitordersdk.Bps(10n), new _limitordersdk.Bps(6000n))), _index1.Whitelist.new(1738650226n, [
+            {
+                address: taker,
+                allowFrom: 0n
+            }
+        ]));
+        var calculatorNoSurplusFee = new _amountcalculator.AmountCalculator(auction, feeCalculator);
+        var takingAmount = 100000n;
+        var makingAmount = 1000n;
+        var surplus = takingAmount / 3n;
+        var estimatedTakingAmount = takingAmount - surplus;
+        var calculator = new _amountcalculator.AmountCalculator(auction, feeCalculator, new _index1.SurplusParams(estimatedTakingAmount, _limitordersdk.Bps.fromPercent(50)));
+        var userAmount = calculatorNoSurplusFee.getUserTakingAmount(taker, makingAmount, takingAmount, makingAmount, execTime);
+        var userAmountWithChargedSurplus = calculator.getUserTakingAmount(taker, makingAmount, takingAmount, makingAmount, execTime);
+        expect(userAmount).toBeGreaterThan(userAmountWithChargedSurplus);
+        expect(userAmount - userAmountWithChargedSurplus).toEqual(surplus / 2n);
+    });
+}) // fee is 50%
+;

package/dist/cjs/amount-calculator/auction-calculator/README.md

@@ -0,0 +1,59 @@
+## AuctionCalculator
+
+**Description:** used to calculate taker amount and auction rate
+
+### Real world example
+
+```typescript
+import {
+    AuctionCalculator,
+    SettlementPostInteractionData,
+    AuctionDetails,
+    Address,
+    bpsToRatioFormat
+} from '@1inch/fusion-sdk'
+
+const startTime = 1673548149n
+const settlementData = SettlementPostInteractionData.new({
+    bankFee: 0n,
+    auctionStartTime: startTime,
+    whitelist: [
+        {
+            address: new Address('0x111111111117dc0aa78b770fa6a738034120c302'),
+            delay: 0n
+        }
+    ],
+    integratorFee: {
+        receiver: new Address('0x111111111117dc0aa78b770fa6a738034120c302'),
+        ratio: bpsToRatioFormat(10)
+    }
+})
+const details = new AuctionDetails({
+    duration: 180n, // in seconds,
+    startTime, // unix timestamp (in sec),
+    initialRateBump: 50000,
+    points: [
+        {
+            delay: 10, // relative to auction start time
+            coefficient: 40000
+        },
+
+        {
+            delay: 10, // relative to previous point
+            coefficient: 40000
+        }
+    ]
+})
+const calculator = AuctionCalculator.fromAuctionData(settlementData, details) // #=> AuctionCalculator instance
+
+const rate = calculator.calcRateBump(startTime + 11n)
+// #=> 40000
+
+const auctionTakingAmount = calculator.calcAuctionTakingAmount(
+    1420000000n,
+    rate
+)
+// #=> 1427105680
+```
+
+