@stryke-xyz/premarket-sdk 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ZX = "0x";
+export declare const getLimitOrderContract: (chainId: number) => string;
+export declare const getNativeOrderFactoryContract: (chainId: number) => string;
+export declare const getNativeOrderImplContract: (chainId: number) => string;

package/dist/constants.js

@@ -0,0 +1,30 @@
+export const ZX = '0x';
+const ONE_INCH_LIMIT_ORDER_V4 = '0x111111125421ca6dc452d289314280a0f8842a65';
+const ONE_INCH_LIMIT_ORDER_V4_ZK_SYNC = '0x6fd4383cb451173d5f9304f041c7bcbf27d561ff';
+// Custom deployment for local testing
+const ONE_INCH_LIMIT_ORDER_V4_LOCAL = '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512';
+const NATIVE_ORDER_FACTORY = '0xe12e0f117d23a5ccc57f8935cd8c4e80cd91ff01';
+const NATIVE_ORDER_FACTORY_ZK_SYNC = '0xfd1d18173d2f179a45bf21f755a261aae7c2d769';
+const NATIVE_ORDER_IMPL = '0xf3eaf3c54f1ef887914b9c19e1ab9d3e581557eb';
+const NATIVE_ORDER_IMPL_ZK_SYNC = '0xf850a926554fc7898d1bda051bc206942909b8f2';
+export const getLimitOrderContract = (chainId) => {
+    if (chainId === 324 /*ZkSync*/) {
+        return ONE_INCH_LIMIT_ORDER_V4_ZK_SYNC;
+    }
+    if (chainId === 31337 /*Anvil/Hardhat local*/) {
+        return ONE_INCH_LIMIT_ORDER_V4_LOCAL;
+    }
+    return ONE_INCH_LIMIT_ORDER_V4;
+};
+export const getNativeOrderFactoryContract = (chainId) => {
+    if (chainId === 324 /*ZkSync*/) {
+        return NATIVE_ORDER_FACTORY_ZK_SYNC;
+    }
+    return NATIVE_ORDER_FACTORY;
+};
+export const getNativeOrderImplContract = (chainId) => {
+    if (chainId === 324 /*ZkSync*/) {
+        return NATIVE_ORDER_IMPL_ZK_SYNC;
+    }
+    return NATIVE_ORDER_IMPL;
+};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./limit-order-contract/index.js";
+export * from "./limit-order/index.js";
+export * from "./rfq-order/index.js";
+export * from "./address.js";
+export * from "./bps.js";
+export * from "./constants.js";
+export * from "./utils/rand-bigint.js";
+export * from "./utils/mul-div.js";
+export * from "./utils/orderUtils.js";
+export type { Order } from "./shared/types.js";
+export { OrderType, OrderStatus, calculateOptionTokenId, } from "./shared/index.js";
+export type { StoredOrder, CreateOrderParams, Option, OrderSignature, OrderQueryParams, OrderResponse, CreateOrderRequest, } from "./shared/index.js";
+export * from "./api/orderbook-api.js";
+export * from "./api/order-helper.js";
+export * from "./api/filler.js";
+export * from "./sync/index.js";
+export * from "./ponder/index.js";
+export * from "./config/index.js";
+export * from "./config/markets.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+export * from "./limit-order-contract/index.js";
+// Export limit-order but exclude Order constant from eip712 to avoid conflict with shared Order interface
+export * from "./limit-order/index.js";
+export * from "./rfq-order/index.js";
+export * from "./address.js";
+export * from "./bps.js";
+export * from "./constants.js";
+export * from "./utils/rand-bigint.js";
+export * from "./utils/mul-div.js";
+export * from "./utils/orderUtils.js";
+export { OrderType, OrderStatus, calculateOptionTokenId, } from "./shared/index.js";
+export * from "./api/orderbook-api.js";
+export * from "./api/order-helper.js";
+export * from "./api/filler.js";
+// Export sync client
+export * from "./sync/index.js";
+// Export Ponder client
+export * from "./ponder/index.js";
+// Export config
+export * from "./config/index.js";
+export * from "./config/markets.js";

package/dist/limit-order/amounts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Calculates taker amount by linear proportion
+ *
+ * @return Ceiled taker amount
+ * @see https://github.com/1inch/limit-order-protocol/blob/23d655844191dea7960a186652307604a1ed480a/contracts/libraries/AmountCalculatorLib.sol#L6
+ */
+export declare function calcTakingAmount(swapMakerAmount: bigint, orderMakerAmount: bigint, orderTakerAmount: bigint): bigint;
+/**
+ * Calculates maker amount by linear proportion
+ *
+ * @return Floored maker amount
+ * @see https://github.com/1inch/limit-order-protocol/blob/23d655844191dea7960a186652307604a1ed480a/contracts/libraries/AmountCalculatorLib.sol#L6
+ */
+export declare function calcMakingAmount(swapTakerAmount: bigint, orderMakerAmount: bigint, orderTakerAmount: bigint): bigint;

package/dist/limit-order/amounts.js

@@ -0,0 +1,19 @@
+/**
+ * Calculates taker amount by linear proportion
+ *
+ * @return Ceiled taker amount
+ * @see https://github.com/1inch/limit-order-protocol/blob/23d655844191dea7960a186652307604a1ed480a/contracts/libraries/AmountCalculatorLib.sol#L6
+ */
+export function calcTakingAmount(swapMakerAmount, orderMakerAmount, orderTakerAmount) {
+    return ((swapMakerAmount * orderTakerAmount + orderMakerAmount - 1n) /
+        orderMakerAmount);
+}
+/**
+ * Calculates maker amount by linear proportion
+ *
+ * @return Floored maker amount
+ * @see https://github.com/1inch/limit-order-protocol/blob/23d655844191dea7960a186652307604a1ed480a/contracts/libraries/AmountCalculatorLib.sol#L6
+ */
+export function calcMakingAmount(swapTakerAmount, orderMakerAmount, orderTakerAmount) {
+    return (swapTakerAmount * orderMakerAmount) / orderTakerAmount;
+}

package/dist/limit-order/eip712/domain.d.ts

@@ -0,0 +1,10 @@
+export declare const EIP712Domain: {
+    name: string;
+    type: string;
+}[];
+export declare const OrderTypeDefinition: {
+    name: string;
+    type: string;
+}[];
+export declare const LimitOrderV4TypeDataName = "1inch Limit Order Protocol";
+export declare const LimitOrderV4TypeDataVersion = "4";

package/dist/limit-order/eip712/domain.js

@@ -0,0 +1,18 @@
+export const EIP712Domain = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' }
+];
+export const OrderTypeDefinition = [
+    { name: 'salt', type: 'uint256' },
+    { name: 'maker', type: 'address' },
+    { name: 'receiver', type: 'address' },
+    { name: 'makerAsset', type: 'address' },
+    { name: 'takerAsset', type: 'address' },
+    { name: 'makingAmount', type: 'uint256' },
+    { name: 'takingAmount', type: 'uint256' },
+    { name: 'makerTraits', type: 'uint256' }
+];
+export const LimitOrderV4TypeDataName = '1inch Limit Order Protocol';
+export const LimitOrderV4TypeDataVersion = '4';

package/dist/limit-order/eip712/eip712.types.d.ts

@@ -0,0 +1,23 @@
+export interface EIP712TypedData {
+    types: EIP712Types;
+    domain: EIP712Object;
+    message: EIP712Object;
+    primaryType: string;
+}
+export interface EIP712Types {
+    [key: string]: EIP712Parameter[];
+}
+export interface EIP712Parameter {
+    name: string;
+    type: string;
+}
+export declare type EIP712ObjectValue = string | bigint | number | EIP712Object;
+export interface EIP712Object {
+    [key: string]: EIP712ObjectValue;
+}
+export type EIP712DomainType = {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+};

package/dist/limit-order/eip712/eip712.types.js

@@ -0,0 +1 @@
+export {};

package/dist/limit-order/eip712/index.d.ts

@@ -0,0 +1,3 @@
+export * from './domain.js';
+export * from './eip712.types.js';
+export * from './order-typed-data-builder.js';

package/dist/limit-order/eip712/index.js

@@ -0,0 +1,3 @@
+export * from './domain.js';
+export * from './eip712.types.js';
+export * from './order-typed-data-builder.js';

package/dist/limit-order/eip712/order-typed-data-builder.d.ts

@@ -0,0 +1,6 @@
+import { EIP712DomainType, EIP712TypedData } from './eip712.types.js';
+import { LimitOrderV4Struct } from '../types.js';
+export declare function getOrderHash(data: EIP712TypedData): string;
+export declare function buildOrderTypedData(chainId: number, verifyingContract: string, name: string, version: string, order: LimitOrderV4Struct): EIP712TypedData;
+export declare function getDomainSeparator(name: string, version: string, chainId: number, verifyingContract: string): string;
+export declare function getLimitOrderV4Domain(chainId: number): EIP712DomainType;

package/dist/limit-order/eip712/order-typed-data-builder.js

@@ -0,0 +1,25 @@
+import { ethers } from 'ethers';
+import { EIP712Domain, LimitOrderV4TypeDataName, LimitOrderV4TypeDataVersion, OrderTypeDefinition as Order } from './domain.js';
+import { getLimitOrderContract } from '../../constants.js';
+export function getOrderHash(data) {
+    return ethers.TypedDataEncoder.hash(data.domain, { Order: data.types.Order }, data.message);
+}
+export function buildOrderTypedData(chainId, verifyingContract, name, version, order) {
+    return {
+        primaryType: 'Order',
+        types: { EIP712Domain, Order },
+        domain: { name, version, chainId, verifyingContract },
+        message: order
+    };
+}
+export function getDomainSeparator(name, version, chainId, verifyingContract) {
+    return ethers.TypedDataEncoder.hashStruct('EIP712Domain', { EIP712Domain: EIP712Domain }, { name, version, chainId, verifyingContract });
+}
+export function getLimitOrderV4Domain(chainId) {
+    return {
+        name: LimitOrderV4TypeDataName,
+        version: LimitOrderV4TypeDataVersion,
+        chainId,
+        verifyingContract: getLimitOrderContract(chainId)
+    };
+}

package/dist/limit-order/extensions/extension-builder.d.ts

@@ -0,0 +1,35 @@
+import { Extension } from './extension.js';
+import { IExtensionBuilder } from '../types.js';
+import { Interaction } from '../interaction.js';
+import { Address } from '../../address.js';
+export declare class ExtensionBuilder implements IExtensionBuilder {
+    private makerAssetSuffix;
+    private takerAssetSuffix;
+    private makingAmountData;
+    private takingAmountData;
+    private predicate;
+    private makerPermit;
+    private preInteraction;
+    private postInteraction;
+    private customData;
+    withMakerAssetSuffix(suffix: string): this;
+    withTakerAssetSuffix(suffix: string): this;
+    /**
+     *
+     * @param address Address of contract which will be called with `data` to calculate making amount
+     * @param data
+     */
+    withMakingAmountData(address: Address, data: string): this;
+    /**
+     *
+     * @param address Address of contract which will be called with `data` to calculate taking amount
+     * @param data
+     */
+    withTakingAmountData(address: Address, data: string): this;
+    withPredicate(predicate: string): this;
+    withMakerPermit(tokenFrom: Address, permitData: string): this;
+    withPreInteraction(interaction: Interaction): this;
+    withPostInteraction(interaction: Interaction): this;
+    withCustomData(data: string): this;
+    build(): Extension;
+}

package/dist/limit-order/extensions/extension-builder.js

@@ -0,0 +1,83 @@
+import { isHexString, trim0x } from '@1inch/byte-utils';
+import assert from 'assert';
+import { Extension } from './extension.js';
+import { ZX } from '../../constants.js';
+export class ExtensionBuilder {
+    constructor() {
+        this.makerAssetSuffix = ZX;
+        this.takerAssetSuffix = ZX;
+        this.makingAmountData = ZX;
+        this.takingAmountData = ZX;
+        this.predicate = ZX;
+        this.makerPermit = ZX;
+        this.preInteraction = ZX;
+        this.postInteraction = ZX;
+        this.customData = ZX;
+    }
+    withMakerAssetSuffix(suffix) {
+        assert(isHexString(suffix), 'MakerAssetSuffix must be valid hex string');
+        this.makerAssetSuffix = suffix;
+        return this;
+    }
+    withTakerAssetSuffix(suffix) {
+        assert(isHexString(suffix), 'TakerAssetSuffix must be valid hex string');
+        this.takerAssetSuffix = suffix;
+        return this;
+    }
+    /**
+     *
+     * @param address Address of contract which will be called with `data` to calculate making amount
+     * @param data
+     */
+    withMakingAmountData(address, data) {
+        assert(isHexString(data), 'MakingAmountData must be valid hex string');
+        this.makingAmountData = address.toString() + trim0x(data);
+        return this;
+    }
+    /**
+     *
+     * @param address Address of contract which will be called with `data` to calculate taking amount
+     * @param data
+     */
+    withTakingAmountData(address, data) {
+        assert(isHexString(data), 'TakingAmountData must be valid hex string');
+        this.takingAmountData = address.toString() + trim0x(data);
+        return this;
+    }
+    withPredicate(predicate) {
+        assert(isHexString(predicate), 'Predicate must be valid hex string');
+        this.predicate = predicate;
+        return this;
+    }
+    withMakerPermit(tokenFrom, permitData) {
+        assert(isHexString(permitData), 'Permit data must be valid hex string');
+        this.makerPermit = tokenFrom.toString() + trim0x(permitData);
+        return this;
+    }
+    withPreInteraction(interaction) {
+        this.preInteraction = interaction.encode();
+        return this;
+    }
+    withPostInteraction(interaction) {
+        this.postInteraction = interaction.encode();
+        return this;
+    }
+    withCustomData(data) {
+        assert(isHexString(data), 'Custom data must be valid hex string');
+        this.customData = data;
+        return this;
+    }
+    build() {
+        return new Extension({
+            makerAssetSuffix: this.makerAssetSuffix,
+            takerAssetSuffix: this.takerAssetSuffix,
+            makingAmountData: this.makingAmountData,
+            takingAmountData: this.takingAmountData,
+            predicate: this.predicate,
+            makerPermit: this.makerPermit,
+            preInteraction: this.preInteraction,
+            postInteraction: this.postInteraction,
+            customData: this.customData
+        });
+    }
+}

package/dist/limit-order/extensions/extension.d.ts

@@ -0,0 +1,45 @@
+export declare class Extension {
+    static EMPTY: {
+        makerAssetSuffix: string;
+        takerAssetSuffix: string;
+        makingAmountData: string;
+        takingAmountData: string;
+        predicate: string;
+        makerPermit: string;
+        preInteraction: string;
+        postInteraction: string;
+        customData: string;
+    };
+    private static fields;
+    readonly makerAssetSuffix: string;
+    readonly takerAssetSuffix: string;
+    readonly makingAmountData: string;
+    readonly takingAmountData: string;
+    readonly predicate: string;
+    readonly makerPermit: string;
+    readonly preInteraction: string;
+    readonly postInteraction: string;
+    readonly customData: string;
+    constructor(data?: {
+        makerAssetSuffix: string;
+        takerAssetSuffix: string;
+        makingAmountData: string;
+        takingAmountData: string;
+        predicate: string;
+        makerPermit: string;
+        preInteraction: string;
+        postInteraction: string;
+        customData: string;
+    });
+    get hasPredicate(): boolean;
+    get hasMakerPermit(): boolean;
+    static decode(bytes: string): Extension;
+    static default(): Extension;
+    keccak256(): bigint;
+    isEmpty(): boolean;
+    /**
+     * Hex string with 0x
+     */
+    encode(): string;
+    private getAll;
+}

package/dist/limit-order/extensions/extension.js

@@ -0,0 +1,108 @@
+import { keccak256 } from 'ethers';
+import { BytesIter, isHexString, trim0x, UINT_32_MAX } from '@1inch/byte-utils';
+import assert from 'assert';
+import { ZX } from '../../constants.js';
+export class Extension {
+    constructor(data = Extension.EMPTY) {
+        this.makerAssetSuffix = ZX;
+        this.takerAssetSuffix = ZX;
+        this.makingAmountData = ZX;
+        this.takingAmountData = ZX;
+        this.predicate = ZX;
+        this.makerPermit = ZX;
+        this.preInteraction = ZX;
+        this.postInteraction = ZX;
+        this.customData = ZX;
+        Object.entries(data).forEach(([key, val]) => assert(isHexString(val) || val === ZX, `${key} must be valid hex string`));
+        this.makerAssetSuffix = data.makerAssetSuffix;
+        this.takerAssetSuffix = data.takerAssetSuffix;
+        this.makingAmountData = data.makingAmountData;
+        this.takingAmountData = data.takingAmountData;
+        this.predicate = data.predicate;
+        this.makerPermit = data.makerPermit;
+        this.preInteraction = data.preInteraction;
+        this.postInteraction = data.postInteraction;
+        this.customData = data.customData;
+    }
+    get hasPredicate() {
+        return this.predicate !== ZX;
+    }
+    get hasMakerPermit() {
+        return this.makerPermit !== ZX;
+    }
+    static decode(bytes) {
+        if (bytes === ZX) {
+            return Extension.default();
+        }
+        const iter = BytesIter.HexString(bytes);
+        let offsets = BigInt(iter.nextUint256());
+        let consumed = 0;
+        const data = {};
+        for (const field of Extension.fields) {
+            const offset = Number(offsets & UINT_32_MAX);
+            const bytesCount = offset - consumed;
+            data[field] = iter.nextBytes(bytesCount);
+            consumed += bytesCount;
+            offsets = offsets >> 32n;
+        }
+        data.customData = iter.rest();
+        return new Extension(data);
+    }
+    static default() {
+        return new Extension();
+    }
+    keccak256() {
+        return BigInt(keccak256(this.encode()));
+    }
+    isEmpty() {
+        const allInteractions = this.getAll();
+        const allInteractionsConcat = allInteractions.map(trim0x).join('') + trim0x(this.customData);
+        return allInteractionsConcat.length === 0;
+    }
+    /**
+     * Hex string with 0x
+     */
+    encode() {
+        const allInteractions = this.getAll();
+        const allInteractionsConcat = allInteractions.map(trim0x).join('') + trim0x(this.customData);
+        // https://stackoverflow.com/a/55261098/440168
+        const cumulativeSum = ((sum) => (value) => {
+            sum += value;
+            return sum;
+        })(0);
+        const offsets = allInteractions
+            .map((a) => a.length / 2 - 1)
+            .map(cumulativeSum)
+            .reduce((acc, a, i) => acc + (BigInt(a) << BigInt(32 * i)), 0n);
+        let extension = '0x';
+        if (allInteractionsConcat.length > 0) {
+            extension +=
+                offsets.toString(16).padStart(64, '0') + allInteractionsConcat;
+        }
+        return extension;
+    }
+    getAll() {
+        return Extension.fields.map((f) => this[f]);
+    }
+}
+Extension.EMPTY = {
+    makerAssetSuffix: ZX,
+    takerAssetSuffix: ZX,
+    makingAmountData: ZX,
+    takingAmountData: ZX,
+    predicate: ZX,
+    makerPermit: ZX,
+    preInteraction: ZX,
+    postInteraction: ZX,
+    customData: ZX
+};
+Extension.fields = [
+    'makerAssetSuffix',
+    'takerAssetSuffix',
+    'makingAmountData',
+    'takingAmountData',
+    'predicate',
+    'makerPermit',
+    'preInteraction',
+    'postInteraction'
+];

package/dist/limit-order/extensions/extension.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/limit-order/extensions/extension.spec.js

@@ -0,0 +1,17 @@
+import { Extension } from './extension.js';
+describe('Extension', () => {
+    it('should encode/decode', () => {
+        const ext = new Extension({
+            makerAssetSuffix: '0x01',
+            takerAssetSuffix: '0x02',
+            makerPermit: '0x03',
+            predicate: '0x04',
+            makingAmountData: '0x05',
+            takingAmountData: '0x06',
+            preInteraction: '0x07',
+            postInteraction: '0x08',
+            customData: '0xff'
+        });
+        expect(Extension.decode(ext.encode())).toStrictEqual(ext);
+    });
+});

package/dist/limit-order/extensions/fee-taker/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class FeeTakerExtensionError extends Error {
+}

package/dist/limit-order/extensions/fee-taker/errors.js

@@ -0,0 +1,2 @@
+export class FeeTakerExtensionError extends Error {
+}

package/dist/limit-order/extensions/fee-taker/fee-calculator.d.ts

@@ -0,0 +1,40 @@
+import { Fees } from './fees.js';
+import { Whitelist } from './types.js';
+import { Address } from '../../../address.js';
+export declare class FeeCalculator {
+    readonly fees: Fees;
+    readonly whitelist: Whitelist;
+    constructor(fees: Fees, whitelist: Whitelist);
+    getTakingAmount(taker: Address, orderTakingAmount: bigint): bigint;
+    getMakingAmount(taker: Address, makingAmount: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getResolverFee(taker: Address, orderTakingAmount: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getIntegratorFee(taker: Address, orderTakingAmount: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which protocol gets as share from integrator fee
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getProtocolShareOfIntegratorFee(taker: Address, orderTakingAmount: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which protocol gets
+     * It equals to `share from integrator fee plus resolver fee`
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getProtocolFee(taker: Address, orderTakingAmount: bigint): bigint;
+    private getFeesForTaker;
+}

package/dist/limit-order/extensions/fee-taker/fee-calculator.js

@@ -0,0 +1,83 @@
+import { Fees } from './fees.js';
+import { mulDiv, Rounding } from '../../../utils/mul-div.js';
+export class FeeCalculator {
+    constructor(fees, whitelist) {
+        this.fees = fees;
+        this.whitelist = whitelist;
+    }
+    getTakingAmount(taker, orderTakingAmount) {
+        const fees = this.getFeesForTaker(taker);
+        return mulDiv(orderTakingAmount, Fees.BASE_1E5 + fees.resolverFee + fees.integratorFee, Fees.BASE_1E5, Rounding.Ceil);
+    }
+    getMakingAmount(taker, makingAmount) {
+        const fees = this.getFeesForTaker(taker);
+        return mulDiv(makingAmount, Fees.BASE_1E5, Fees.BASE_1E5 + fees.resolverFee + fees.integratorFee);
+    }
+    /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getResolverFee(taker, orderTakingAmount) {
+        // the logic copied from contract to avoid calculation issues
+        // @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/FeeTaker.sol#L145
+        const takingAmount = this.getTakingAmount(taker, orderTakingAmount);
+        const fees = this.getFeesForTaker(taker);
+        return mulDiv(takingAmount, fees.resolverFee, Fees.BASE_1E5 + fees.resolverFee + fees.integratorFee);
+    }
+    /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getIntegratorFee(taker, orderTakingAmount) {
+        // the logic copied from contract to avoid calculation issues
+        // @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/FeeTaker.sol#L145
+        const takingAmount = this.getTakingAmount(taker, orderTakingAmount);
+        const fees = this.getFeesForTaker(taker);
+        const total = mulDiv(takingAmount, fees.integratorFee, Fees.BASE_1E5 + fees.resolverFee + fees.integratorFee);
+        return mulDiv(total, BigInt(this.fees.integrator.share.toFraction(Fees.BASE_1E2)), Fees.BASE_1E2);
+    }
+    /**
+     * Fee in `takerAsset` which protocol gets as share from integrator fee
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getProtocolShareOfIntegratorFee(taker, orderTakingAmount) {
+        // the logic copied from contract to avoid calculation issues
+        // @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/FeeTaker.sol#L145
+        const takingAmount = this.getTakingAmount(taker, orderTakingAmount);
+        const fees = this.getFeesForTaker(taker);
+        const total = mulDiv(takingAmount, fees.integratorFee, Fees.BASE_1E5 + fees.resolverFee + fees.integratorFee);
+        return total - this.getIntegratorFee(taker, orderTakingAmount);
+    }
+    /**
+     * Fee in `takerAsset` which protocol gets
+     * It equals to `share from integrator fee plus resolver fee`
+     *
+     * @param taker who will fill order
+     * @param orderTakingAmount taking amount from order struct
+     */
+    getProtocolFee(taker, orderTakingAmount) {
+        const resolverFee = this.getResolverFee(taker, orderTakingAmount);
+        const integratorPart = this.getProtocolShareOfIntegratorFee(taker, orderTakingAmount);
+        return integratorPart + resolverFee;
+    }
+    getFeesForTaker(taker) {
+        const discountNumerator = this.whitelist.isWhitelisted(taker)
+            ? Number(Fees.BASE_1E2) -
+                this.fees.resolver.whitelistDiscount.toFraction(Fees.BASE_1E2)
+            : 100;
+        const resolverFee = BigInt(discountNumerator *
+            this.fees.resolver.fee.toFraction(Fees.BASE_1E5)) / Fees.BASE_1E2;
+        const resolverFeeBN = BigInt(resolverFee);
+        const integratorFeeBN = BigInt(this.fees.integrator.fee.toFraction(Fees.BASE_1E5));
+        return {
+            resolverFee: resolverFeeBN,
+            integratorFee: integratorFeeBN
+        };
+    }
+}

package/dist/limit-order/extensions/fee-taker/fee-calculator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/limit-order/extensions/fee-taker/fee-calculator.spec.js

@@ -0,0 +1,14 @@
+import { FeeCalculator } from './fee-calculator.js';
+import { IntegratorFee } from './integrator-fee.js';
+import { WhitelistHalfAddress } from './whitelist-half-address.js';
+import { Fees } from './fees.js';
+import { Address } from '../../../address.js';
+import { Bps } from '../../../bps.js';
+describe('FeeCalculator', () => {
+    it('should calculate protocol fee amount', () => {
+        // https://etherscan.io/tx/0x8f95dc0e6e836ca0abdad88e20cf61b0caf7c5463d67b577740f3084d428e56e
+        const calculator = new FeeCalculator(Fees.integratorFee(new IntegratorFee(new Address('0x8e097e5e0493de033270a01b324caf31f464dc67'), new Address('0x90cbe4bdd538d6e9b379bff5fe72c3d67a521de5'), new Bps(10n), new Bps(6000n))), WhitelistHalfAddress.new([Address.fromBigInt(1n)]));
+        const protocolFee = calculator.getProtocolFee(Address.ZERO_ADDRESS, 18442227n);
+        expect(protocolFee).toBe(7377n);
+    });
+});