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

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

@@ -1,81 +1,271 @@
-import { Bps, FeeTakerExt, mulDiv, Rounding } from '@1inch/limit-order-sdk';
-import { Fees } from '@1inch/limit-order-sdk/extensions/fee-taker';
-import { AuctionCalculator } from './auction-calculator';
-import { SurplusParams } from '../fusion-order';
-export class AmountCalculator {
-    constructor(auctionCalculator, feeCalculator, surplus = SurplusParams.NO_FEE) {
+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;
+}
+import { Bps, mulDiv, Rounding, FeeTakerExt } from '@1inch/limit-order-sdk';
+import { AuctionCalculator } from './auction-calculator/index.js';
+import { SurplusParams } from '../fusion-order/index.js';
+import { Fees } from '../fusion-order/fees/index.js';
+/**
+ * Calculates fees/amount with accounting to auction
+ *
+ * @see FusionOrder
+ */ export var AmountCalculator = /*#__PURE__*/ function() {
+    "use strict";
+    function AmountCalculator(auctionCalculator, feeCalculator) {
+        var surplus = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 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;
     }
-    static fromExtension(ext) {
-        return new AmountCalculator(AuctionCalculator.fromAuctionData(ext.auctionDetails), ext.extra?.fees
-            ? new FeeTakerExt.FeeCalculator(ext.extra?.fees, ext.whitelist)
-            : undefined, ext.surplus);
-    }
-    static calcAuctionTakingAmount(baseTakingAmount, rate, fee = Bps.ZERO) {
-        const withoutFee = AuctionCalculator.calcAuctionTakingAmount(baseTakingAmount, rate);
-        if (fee.isZero()) {
-            return withoutFee;
+    _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 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 = 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 AuctionCalculator.calcAuctionTakingAmount(takingAmount, rateBump);
+            }
         }
-        const numerator = Fees.BASE_1E5 + BigInt(fee.toFraction(Fees.BASE_1E5));
-        return (withoutFee * numerator) / Fees.BASE_1E5;
-    }
-    static extractFeeAmount(requiredTakingAmount, fee) {
-        return (requiredTakingAmount -
-            mulDiv(requiredTakingAmount, Fees.BASE_1E5, Fees.BASE_1E5 + BigInt(fee.toFraction(Fees.BASE_1E5)), 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 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);
-    }
-    getResolverFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getResolverFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
-    }
-    getIntegratorFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getIntegratorFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
-    }
-    getProtocolShareOfIntegratorFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getProtocolShareOfIntegratorFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
-    }
-    getProtocolFee(taker, takingAmount, time, blockBaseFee = 0n) {
-        return (this.feeCalculator?.getProtocolFee(taker, this.getAuctionBumpedAmount(takingAmount, time, blockBaseFee)) ?? 0n);
-    }
-    _getSurplusFee(userTakingAmount, makingAmount, orderMakingAmount) {
-        const estimatedTakingAmount = mulDiv(this.surplus.estimatedTakerAmount, makingAmount, orderMakingAmount);
-        if (userTakingAmount > estimatedTakingAmount) {
-            const surplusFee = ((userTakingAmount - estimatedTakingAmount) *
-                BigInt(this.surplus.protocolFee.toPercent())) /
-                100n;
-            return surplusFee;
+    ], [
+        {
+            key: "fromExtension",
+            value: function fromExtension(ext) {
+                var _ext_extra, _ext_extra1;
+                return new AmountCalculator(AuctionCalculator.fromAuctionData(ext.auctionDetails), ((_ext_extra = ext.extra) === null || _ext_extra === void 0 ? void 0 : _ext_extra.fees) ? new 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] : Bps.ZERO;
+                var withoutFee = AuctionCalculator.calcAuctionTakingAmount(baseTakingAmount, rate);
+                if (fee.isZero()) {
+                    return withoutFee;
+                }
+                var numerator = Fees.BASE_1E5 + BigInt(fee.toFraction(Fees.BASE_1E5));
+                return withoutFee * numerator / 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 - mulDiv(requiredTakingAmount, Fees.BASE_1E5, Fees.BASE_1E5 + BigInt(fee.toFraction(Fees.BASE_1E5)), Rounding.Ceil);
+            }
         }
-        return 0n;
-    }
-    getAuctionBumpedAmount(takingAmount, time, blockBaseFee = 0n) {
-        const rateBump = this.auctionCalculator.calcRateBump(time, blockBaseFee);
-        return AuctionCalculator.calcAuctionTakingAmount(takingAmount, rateBump);
-    }
-}
-//# sourceMappingURL=amount-calculator.js.map
+    ]);
+    return AmountCalculator;
+}();

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

@@ -0,0 +1,62 @@
+import { FeeTakerExt, Address, Bps } from '@1inch/limit-order-sdk';
+import { AmountCalculator } from './amount-calculator.js';
+import { AuctionCalculator } from './auction-calculator/index.js';
+import { SurplusParams, Whitelist } from '../fusion-order/index.js';
+import { now } from '../utils/time.js';
+import { Fees, IntegratorFee } from '../fusion-order/fees/index.js';
+describe('AmountCalculator', function() {
+    it('should correct extract fee', function() {
+        var integratorFeeBps = new Bps(6n);
+        // 60% from 10bps
+        var calculator = new AmountCalculator(new AuctionCalculator(1738650250n, 180n, 1218519n, [
+            {
+                coefficient: 609353,
+                delay: 180
+            }
+        ], {
+            gasBumpEstimate: 609353n,
+            gasPriceEstimate: 1526n
+        }), new FeeTakerExt.FeeCalculator(Fees.integratorFee(new IntegratorFee(new Address('0x8e097e5e0493de033270a01b324caf31f464dc67'), new Address('0x90cbe4bdd538d6e9b379bff5fe72c3d67a521de5'), new Bps(10n), new Bps(6000n))), Whitelist.new(1738650226n, [
+            {
+                address: Address.fromBigInt(1n),
+                allowFrom: 0n
+            }
+        ])));
+        var takingAmount = 100000n;
+        var requiredTakingAmount = calculator.getRequiredTakingAmount(Address.ZERO_ADDRESS, takingAmount, now(), 10n);
+        var integratorFee = calculator.getIntegratorFee(Address.ZERO_ADDRESS, takingAmount, now(), 10n);
+        expect(AmountCalculator.extractFeeAmount(requiredTakingAmount, integratorFeeBps)).toEqual(integratorFee);
+    });
+    it('should apply surplus', function() {
+        var startTime = 1738650250n;
+        var execTime = startTime + 180n;
+        // end of auction
+        var auction = new AuctionCalculator(startTime, 180n, 1218519n, [
+            {
+                coefficient: 609353,
+                delay: 180
+            }
+        ], {
+            gasBumpEstimate: 609353n,
+            gasPriceEstimate: 1526n
+        });
+        var taker = Address.fromBigInt(1n);
+        var feeCalculator = new FeeTakerExt.FeeCalculator(Fees.integratorFee(new IntegratorFee(new Address('0x8e097e5e0493de033270a01b324caf31f464dc67'), new Address('0x90cbe4bdd538d6e9b379bff5fe72c3d67a521de5'), new Bps(10n), new Bps(6000n))), Whitelist.new(1738650226n, [
+            {
+                address: taker,
+                allowFrom: 0n
+            }
+        ]));
+        var calculatorNoSurplusFee = new AmountCalculator(auction, feeCalculator);
+        var takingAmount = 100000n;
+        var makingAmount = 1000n;
+        var surplus = takingAmount / 3n;
+        var estimatedTakingAmount = takingAmount - surplus;
+        var calculator = new AmountCalculator(auction, feeCalculator, new SurplusParams(estimatedTakingAmount, 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/esm/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
+```
+
+