@stryke-xyz/premarket-sdk 1.0.0

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

@@ -0,0 +1,130 @@
+import { Fees } from './fees.js';
+import { WhitelistHalfAddress } from './whitelist-half-address.js';
+import { FeeCalculator } from './fee-calculator.js';
+import { Address } from '../../../address.js';
+import { Interaction } from '../../interaction.js';
+import { Extension } from '../extension.js';
+/**
+ * @see https://github.com/1inch/limit-order-protocol/blob/master/contracts/extensions/FeeTaker.sol
+ */
+export declare class FeeTakerExtension {
+    readonly address: Address;
+    readonly fees: Fees;
+    readonly whitelist: WhitelistHalfAddress;
+    readonly makerPermit?: Interaction | undefined;
+    readonly extraInteraction?: Interaction | undefined;
+    readonly customReceiver?: Address | undefined;
+    /**
+     * Flags for post-interaction data
+     * @private
+     */
+    private static CUSTOM_RECEIVER_FLAG_BIT;
+    private constructor();
+    static new(
+    /**
+     * Address of extension
+     */
+    address: Address, 
+    /**
+     * @see ResolverFee
+     * @see IntegratorFee
+     */
+    fees: Fees, 
+    /**
+     * If empty, then KYC token is required to fill order
+     */
+    whitelist?: Address[], extra?: {
+        makerPermit?: Interaction;
+        /**
+         * In case receiver of taker tokens is not maker
+         */
+        customReceiver?: Address;
+        /**
+         * Will be called after FeeTaker.postInteraction
+         */
+        extraInteraction?: Interaction;
+    }): FeeTakerExtension;
+    /**
+     * Create `FeeTakerExtension` from bytes
+     *
+     * @param bytes 0x prefixed bytes
+     */
+    static decode(bytes: string): FeeTakerExtension;
+    /**
+     * Create `FeeTakerExtension` from `Extension`
+     */
+    static fromExtension(extension: Extension): FeeTakerExtension;
+    getFeeCalculator(): FeeCalculator;
+    build(): Extension;
+    /**
+     * Returns takingAmount with applied fees to it
+     *
+     * @param taker address which fill order
+     * @param takingAmount amount to apply fee to
+     */
+    getTakingAmount(taker: Address, takingAmount: bigint): bigint;
+    /**
+     * Returns makingAmount with applied fees to it
+     *
+     * @param taker address which fill order
+     * @param makingAmount amount to apply fee to
+     */
+    getMakingAmount(taker: Address, makingAmount: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to apply fee to
+     */
+    getResolverFee(taker: Address, takingAmount: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to calculate fee from
+     */
+    getIntegratorFee(taker: Address, takingAmount: bigint): bigint;
+    /**
+     * 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
+     */
+    getProtocolShareOfIntegratorFee(taker: Address, takingAmount: 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 takingAmount taking amount to calculate fee from
+     */
+    getProtocolFee(taker: Address, takingAmount: bigint): bigint;
+    /**
+     * Build data for AmountGetterWithFee
+     *
+     * 2 bytes — integrator fee percentage (in 1e5)
+     * 1 byte - integrator share percentage (in 1e2)
+     * 2 bytes — resolver fee percentage (in 1e5)
+     * 1 byte - whitelist discount numerator (in 1e2)
+     * 1 byte - size of the whitelist
+     * (bytes10)[N] whitelisted addresses;
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/AmountGetterWithFee.sol#L56
+     */
+    private buildAmountGetterData;
+    /**
+     * Build data for `FeeTaker.postInteraction`
+     *
+     *
+     * 1 byte - flags:
+     *      01 bit `CUSTOM_RECEIVER_FLAG` - set to 1 if order has custom receiver
+     * 20 bytes — integrator fee recipient
+     * 20 bytes - protocol fee recipient
+     * [20 bytes] — receiver of taking tokens (optional, if not set, maker is used). See `CUSTOM_RECEIVER_FLAG` flag
+     * Same as in `buildAmountGetterData`
+     * [bytes20, bytes] - optional extra interaction
+     * @see buildAmountGetterData
+     * @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/FeeTaker.sol#L114
+     */
+    private buildInteractionData;
+}

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

@@ -0,0 +1,249 @@
+import { BN, BytesBuilder, BytesIter } from '@1inch/byte-utils';
+import assert from 'assert';
+import { Fees } from './fees.js';
+import { ResolverFee } from './resolver-fee.js';
+import { IntegratorFee } from './integrator-fee.js';
+import { WhitelistHalfAddress } from './whitelist-half-address.js';
+import { FeeCalculator } from './fee-calculator.js';
+import { ExtensionBuilder } from '../extension-builder.js';
+import { Address } from '../../../address.js';
+import { Interaction } from '../../interaction.js';
+import { Extension } from '../extension.js';
+import { Bps } from '../../../bps.js';
+/**
+ * @see https://github.com/1inch/limit-order-protocol/blob/master/contracts/extensions/FeeTaker.sol
+ */
+export class FeeTakerExtension {
+    constructor(address, fees, whitelist, makerPermit, extraInteraction, customReceiver) {
+        this.address = address;
+        this.fees = fees;
+        this.whitelist = whitelist;
+        this.makerPermit = makerPermit;
+        this.extraInteraction = extraInteraction;
+        this.customReceiver = customReceiver;
+    }
+    static new(
+    /**
+     * Address of extension
+     */
+    address, 
+    /**
+     * @see ResolverFee
+     * @see IntegratorFee
+     */
+    fees, 
+    /**
+     * If empty, then KYC token is required to fill order
+     */
+    whitelist, extra) {
+        return new FeeTakerExtension(address, fees, WhitelistHalfAddress.new(whitelist || []), extra?.makerPermit, extra?.extraInteraction, extra?.customReceiver);
+    }
+    /**
+     * Create `FeeTakerExtension` from bytes
+     *
+     * @param bytes 0x prefixed bytes
+     */
+    static decode(bytes) {
+        const extension = Extension.decode(bytes);
+        return FeeTakerExtension.fromExtension(extension);
+    }
+    /**
+     * Create `FeeTakerExtension` from `Extension`
+     */
+    static fromExtension(extension) {
+        const extensionAddress = Address.fromFirstBytes(extension.makingAmountData);
+        assert(Address.fromFirstBytes(extension.takingAmountData).equal(extensionAddress) &&
+            Address.fromFirstBytes(extension.postInteraction).equal(extensionAddress), 'Invalid extension, all calls should be to the same address');
+        assert(extension.takingAmountData == extension.makingAmountData, 'Invalid extension, taking amount data must be equal to making amount data');
+        // region Parse postInteraction data
+        const interactionBytes = BytesIter.HexString(extension.postInteraction);
+        interactionBytes.nextUint160(); // skip address of extension
+        const flags = BN.fromHex(interactionBytes.nextUint8());
+        const integratorFeeRecipient = new Address(interactionBytes.nextUint160());
+        const protocolFeeRecipient = new Address(interactionBytes.nextUint160());
+        const customTokensRecipient = flags.getBit(FeeTakerExtension.CUSTOM_RECEIVER_FLAG_BIT)
+            ? new Address(interactionBytes.nextUint160())
+            : undefined;
+        const interactionData = parseAmountData(interactionBytes);
+        const extraInteraction = interactionBytes.isEmpty()
+            ? undefined
+            : Interaction.decode(interactionBytes.rest());
+        //endregion Parse postInteraction data
+        //region Parse amount data
+        const amountBytes = BytesIter.HexString(extension.makingAmountData);
+        amountBytes.nextUint160(); // skip address of extension
+        const amountData = parseAmountData(amountBytes);
+        //endregion Parse amount data
+        const permit = extension.hasMakerPermit
+            ? Interaction.decode(extension.makerPermit)
+            : undefined;
+        assert(amountData.fees.integratorFee.value ===
+            interactionData.fees.integratorFee.value, `invalid extension: integrator fee must be same in interaction data and in amount data`);
+        assert(amountData.fees.resolverFee.value ===
+            interactionData.fees.resolverFee.value, `invalid extension: resolver fee must be same in interaction data and in amount data`);
+        assert(amountData.whitelist.discount.value ===
+            interactionData.whitelist.discount.value, `invalid extension: whitelist discount fee must be same in interaction data and in amount data`);
+        assert(amountData.fees.integratorShare.value ===
+            interactionData.fees.integratorShare.value, `invalid extension: integrator share must be same in interaction data and in amount data`);
+        assert(interactionData.whitelist.addresses.length ===
+            amountData.whitelist.addresses.length, 'whitelist must be same in interaction data and in amount data');
+        assert(interactionData.whitelist.addresses.every((val, i) => amountData.whitelist.addresses[i] === val), 'whitelist must be same in interaction data and in amount data');
+        return new FeeTakerExtension(extensionAddress, new Fees(amountData.fees.resolverFee.isZero()
+            ? ResolverFee.ZERO
+            : new ResolverFee(protocolFeeRecipient, amountData.fees.resolverFee, amountData.whitelist.discount), amountData.fees.integratorFee.isZero()
+            ? IntegratorFee.ZERO
+            : new IntegratorFee(integratorFeeRecipient, protocolFeeRecipient, amountData.fees.integratorFee, amountData.fees.integratorShare)), new WhitelistHalfAddress(amountData.whitelist.addresses), permit, extraInteraction, customTokensRecipient);
+    }
+    getFeeCalculator() {
+        return new FeeCalculator(this.fees, this.whitelist);
+    }
+    build() {
+        const amountGetterData = this.buildAmountGetterData();
+        const builder = new ExtensionBuilder()
+            .withMakingAmountData(this.address, amountGetterData)
+            .withTakingAmountData(this.address, amountGetterData)
+            .withPostInteraction(new Interaction(this.address, this.buildInteractionData()));
+        if (this.makerPermit) {
+            builder.withMakerPermit(this.makerPermit.target, this.makerPermit.data);
+        }
+        return builder.build();
+    }
+    /**
+     * Returns takingAmount with applied fees to it
+     *
+     * @param taker address which fill order
+     * @param takingAmount amount to apply fee to
+     */
+    getTakingAmount(taker, takingAmount) {
+        return this.getFeeCalculator().getTakingAmount(taker, takingAmount);
+    }
+    /**
+     * Returns makingAmount with applied fees to it
+     *
+     * @param taker address which fill order
+     * @param makingAmount amount to apply fee to
+     */
+    getMakingAmount(taker, makingAmount) {
+        return this.getFeeCalculator().getMakingAmount(taker, makingAmount);
+    }
+    /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to apply fee to
+     */
+    getResolverFee(taker, takingAmount) {
+        return this.getFeeCalculator().getResolverFee(taker, takingAmount);
+    }
+    /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param takingAmount taking amount to calculate fee from
+     */
+    getIntegratorFee(taker, takingAmount) {
+        return this.getFeeCalculator().getIntegratorFee(taker, takingAmount);
+    }
+    /**
+     * 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
+     */
+    getProtocolShareOfIntegratorFee(taker, takingAmount) {
+        return this.getFeeCalculator().getProtocolShareOfIntegratorFee(taker, takingAmount);
+    }
+    /**
+     * 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
+     */
+    getProtocolFee(taker, takingAmount) {
+        return this.getFeeCalculator().getProtocolFee(taker, takingAmount);
+    }
+    /**
+     * Build data for AmountGetterWithFee
+     *
+     * 2 bytes — integrator fee percentage (in 1e5)
+     * 1 byte - integrator share percentage (in 1e2)
+     * 2 bytes — resolver fee percentage (in 1e5)
+     * 1 byte - whitelist discount numerator (in 1e2)
+     * 1 byte - size of the whitelist
+     * (bytes10)[N] whitelisted addresses;
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/AmountGetterWithFee.sol#L56
+     */
+    buildAmountGetterData() {
+        const integrator = {
+            fee: this.fees.integrator.fee.toFraction(Fees.BASE_1E5),
+            share: this.fees.integrator.share.toFraction(Fees.BASE_1E2)
+        };
+        const resolverFee = this.fees.resolver.fee.toFraction(Fees.BASE_1E5);
+        const builder = new BytesBuilder()
+            .addUint16(BigInt(integrator.fee))
+            .addUint8(BigInt(integrator.share))
+            .addUint16(BigInt(resolverFee))
+            .addUint8(BigInt(
+        // contract expects discount numerator, but class contain discount
+        Number(Fees.BASE_1E2) -
+            this.fees.resolver.whitelistDiscount.toFraction(Fees.BASE_1E2)));
+        this.whitelist.encodeTo(builder);
+        return builder.asHex();
+    }
+    /**
+     * Build data for `FeeTaker.postInteraction`
+     *
+     *
+     * 1 byte - flags:
+     *      01 bit `CUSTOM_RECEIVER_FLAG` - set to 1 if order has custom receiver
+     * 20 bytes — integrator fee recipient
+     * 20 bytes - protocol fee recipient
+     * [20 bytes] — receiver of taking tokens (optional, if not set, maker is used). See `CUSTOM_RECEIVER_FLAG` flag
+     * Same as in `buildAmountGetterData`
+     * [bytes20, bytes] - optional extra interaction
+     * @see buildAmountGetterData
+     * @see https://github.com/1inch/limit-order-protocol/blob/22a18f7f20acfec69d4f50ce1880e8e662477710/contracts/extensions/FeeTaker.sol#L114
+     */
+    buildInteractionData() {
+        const flags = new BN(0n).setBit(FeeTakerExtension.CUSTOM_RECEIVER_FLAG_BIT, Boolean(this.customReceiver));
+        const builder = new BytesBuilder()
+            .addUint8(flags)
+            .addAddress(this.fees.integrator.integrator.toString())
+            .addAddress(this.fees.protocol.toString());
+        if (this.customReceiver) {
+            builder.addAddress(this.customReceiver.toString());
+        }
+        builder.addBytes(this.buildAmountGetterData());
+        if (this.extraInteraction) {
+            builder
+                .addAddress(this.extraInteraction.target.toString())
+                .addBytes(this.extraInteraction.data);
+        }
+        return builder.asHex();
+    }
+}
+/**
+ * Flags for post-interaction data
+ * @private
+ */
+FeeTakerExtension.CUSTOM_RECEIVER_FLAG_BIT = 0n;
+function parseAmountData(iter) {
+    const fees = {
+        integratorFee: Bps.fromFraction(Number(iter.nextUint16()), Fees.BASE_1E5),
+        integratorShare: Bps.fromFraction(Number(iter.nextUint8()), Fees.BASE_1E2),
+        resolverFee: Bps.fromFraction(Number(iter.nextUint16()), Fees.BASE_1E5)
+    };
+    const whitelistDiscount = Bps.fromFraction(Number(Fees.BASE_1E2) - Number(iter.nextUint8()), // contract uses 1 - discount
+    Fees.BASE_1E2);
+    const whitelistAddresses = [];
+    const whitelistFromAmountSize = Number(iter.nextUint8());
+    for (let i = 0; i < whitelistFromAmountSize; i++) {
+        whitelistAddresses.push(iter.nextBytes(10));
+    }
+    return {
+        fees,
+        whitelist: { discount: whitelistDiscount, addresses: whitelistAddresses }
+    };
+}

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

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

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

@@ -0,0 +1,72 @@
+import { FeeTakerExtension } from './fee-taker.extension.js';
+import { Fees } from './fees.js';
+import { ResolverFee } from './resolver-fee.js';
+import { IntegratorFee } from './integrator-fee.js';
+import { Address } from '../../../address.js';
+import { Bps } from '../../../bps.js';
+import { Interaction } from '../../interaction.js';
+describe('FeeTakerExtension', () => {
+    describe('serialize/deserialize', () => {
+        it('all data', () => {
+            const recipients = {
+                integratorFeeRecipient: Address.fromBigInt(2n),
+                protocolFeeRecipient: Address.fromBigInt(3n),
+                tokensRecipient: Address.fromBigInt(4n)
+            };
+            const extension = FeeTakerExtension.new(Address.fromBigInt(1n), new Fees(new ResolverFee(recipients.protocolFeeRecipient, Bps.fromPercent(2), Bps.fromPercent(1)), new IntegratorFee(recipients.integratorFeeRecipient, recipients.protocolFeeRecipient, Bps.fromFraction(0.0001), Bps.fromPercent(5))), [Address.fromBigInt(100n)], {
+                makerPermit: new Interaction(Address.fromBigInt(1n), '0xdeadbeef'),
+                extraInteraction: new Interaction(Address.fromBigInt(99n), '0xdeadbeefdeadbeef'),
+                customReceiver: recipients.tokensRecipient
+            });
+            expect(FeeTakerExtension.fromExtension(extension.build())).toEqual(extension);
+        });
+        it('only resolver data', () => {
+            const recipients = {
+                protocolFeeRecipient: Address.fromBigInt(3n)
+            };
+            const extension = FeeTakerExtension.new(Address.fromBigInt(1n), Fees.resolverFee(new ResolverFee(recipients.protocolFeeRecipient, Bps.fromPercent(2))), [Address.fromBigInt(100n)]);
+            expect(FeeTakerExtension.fromExtension(extension.build())).toEqual(extension);
+        });
+        it('only integrator data', () => {
+            const recipients = {
+                integratorFeeRecipient: Address.fromBigInt(2n),
+                protocolFeeRecipient: Address.fromBigInt(3n)
+            };
+            const extension = FeeTakerExtension.new(Address.fromBigInt(1n), Fees.integratorFee(new IntegratorFee(recipients.integratorFeeRecipient, recipients.protocolFeeRecipient, Bps.fromFraction(0.0001), Bps.fromPercent(5))), [Address.fromBigInt(100n)]);
+            expect(FeeTakerExtension.fromExtension(extension.build())).toEqual(extension);
+        });
+    });
+    it('should calculate taking amount', () => {
+        const takerAddress = Address.fromBigInt(100n);
+        const ext = FeeTakerExtension.new(Address.fromBigInt(1n), Fees.resolverFee(new ResolverFee(Address.fromBigInt(2n), Bps.fromPercent(1))), [takerAddress] // mark taker as whitelisted resolver
+        );
+        const takingAmount = ext.getTakingAmount(takerAddress, 100000000n);
+        expect(takingAmount).toEqual(101000000n);
+    });
+    it('should calculate resolver fee', () => {
+        const takerAddress = Address.fromBigInt(100n);
+        const ext = FeeTakerExtension.new(Address.fromBigInt(1n), Fees.resolverFee(new ResolverFee(Address.fromBigInt(2n), Bps.fromPercent(1))), [takerAddress] // mark taker as whitelisted resolver
+        );
+        const resolverFee = ext.getResolverFee(takerAddress, 100000000n);
+        expect(resolverFee).toEqual(1000000n);
+    });
+    it('should calculate integrator fee', () => {
+        const takerAddress = Address.fromBigInt(100n);
+        const ext = FeeTakerExtension.new(Address.fromBigInt(1n), Fees.integratorFee(new IntegratorFee(Address.fromBigInt(2n), Address.fromBigInt(3n), Bps.fromPercent(5), // fee
+        Bps.fromPercent(10) // share
+        )), [takerAddress] // mark taker as whitelisted resolver
+        );
+        const integratorFee = ext.getIntegratorFee(takerAddress, 100000000n);
+        expect(integratorFee).toEqual(500000n); // 10% from 5% = 0.5%
+    });
+    it('should calculate protocol fee', () => {
+        const protocolAddress = Address.fromBigInt(111n);
+        const takerAddress = Address.fromBigInt(100n);
+        const ext = FeeTakerExtension.new(Address.fromBigInt(1n), new Fees(new ResolverFee(protocolAddress, Bps.fromPercent(1)), new IntegratorFee(Address.fromBigInt(2n), protocolAddress, Bps.fromPercent(5), // fee
+        Bps.fromPercent(10) // share
+        )), [takerAddress] // mark taker as whitelisted resolver
+        );
+        const protocolFee = ext.getProtocolFee(takerAddress, 100000000n);
+        expect(protocolFee).toEqual(1000000n + 4500000n); // 90% from 5% (integrator fee share)+ 1% (resolver fee) = 5.5%
+    });
+});

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

@@ -0,0 +1,19 @@
+import { ResolverFee } from './resolver-fee.js';
+import { IntegratorFee } from './integrator-fee.js';
+import { Address } from '../../../address.js';
+export declare class Fees {
+    readonly resolver: ResolverFee;
+    readonly integrator: IntegratorFee;
+    /**
+     * 100% = 100000
+     */
+    static BASE_1E5: bigint;
+    /**
+     * 100% = 100
+     */
+    static BASE_1E2: bigint;
+    constructor(resolver: ResolverFee, integrator: IntegratorFee);
+    get protocol(): Address;
+    static resolverFee(fee: ResolverFee): Fees;
+    static integratorFee(fee: IntegratorFee): Fees;
+}

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

@@ -0,0 +1,36 @@
+import assert from 'assert';
+import { ResolverFee } from './resolver-fee.js';
+import { IntegratorFee } from './integrator-fee.js';
+export class Fees {
+    constructor(resolver, integrator) {
+        this.resolver = resolver;
+        this.integrator = integrator;
+        if (!resolver.fee.isZero() && !integrator.fee.isZero()) {
+            assert(resolver.receiver.equal(integrator.protocol), 'resolver fee receiver address and integrator fee protocol address must be same');
+        }
+        assert(!(resolver.fee.isZero() && integrator.fee.isZero()), 'at least one fee must be set');
+        assert(this.integrator.fee.toFraction() < 0.6553, 'max fee is 65.53%' // 2bytes
+        );
+        assert(this.resolver.fee.toFraction() < 0.6553, 'max fee is 65.53%' // 2bytes
+        );
+    }
+    get protocol() {
+        return this.integrator.fee.isZero()
+            ? this.resolver.receiver
+            : this.integrator.protocol;
+    }
+    static resolverFee(fee) {
+        return new Fees(fee, IntegratorFee.ZERO);
+    }
+    static integratorFee(fee) {
+        return new Fees(ResolverFee.ZERO, fee);
+    }
+}
+/**
+ * 100% = 100000
+ */
+Fees.BASE_1E5 = 100000n;
+/**
+ * 100% = 100
+ */
+Fees.BASE_1E2 = 100n;

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

@@ -0,0 +1,7 @@
+export * from './fee-taker.extension.js';
+export * from './fees.js';
+export * from './integrator-fee.js';
+export * from './resolver-fee.js';
+export * from './fee-calculator.js';
+export * from './types.js';
+export * from './whitelist-half-address.js';

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

@@ -0,0 +1,7 @@
+export * from './fee-taker.extension.js';
+export * from './fees.js';
+export * from './integrator-fee.js';
+export * from './resolver-fee.js';
+export * from './fee-calculator.js';
+export * from './types.js';
+export * from './whitelist-half-address.js';

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

@@ -0,0 +1,13 @@
+import { Address } from '../../../address.js';
+import { Bps } from '../../../bps.js';
+/**
+ * Integrator gets `share` of `fee` to `integrator` and the rest goes to `protocol`
+ */
+export declare class IntegratorFee {
+    readonly integrator: Address;
+    readonly protocol: Address;
+    readonly fee: Bps;
+    readonly share: Bps;
+    static ZERO: IntegratorFee;
+    constructor(integrator: Address, protocol: Address, fee: Bps, share: Bps);
+}

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

@@ -0,0 +1,28 @@
+import { Address } from '../../../address.js';
+import { Bps } from '../../../bps.js';
+/**
+ * Integrator gets `share` of `fee` to `integrator` and the rest goes to `protocol`
+ */
+export class IntegratorFee {
+    constructor(integrator, protocol, fee, share) {
+        this.integrator = integrator;
+        this.protocol = protocol;
+        this.fee = fee;
+        this.share = share;
+        if (fee.isZero()) {
+            if (!share.isZero()) {
+                throw new Error('integrator share must be zero if fee is zero');
+            }
+            if (!integrator.isZero()) {
+                throw new Error('integrator address must be zero if fee is zero');
+            }
+            if (!protocol.isZero()) {
+                throw new Error('protocol address must be zero if fee is zero');
+            }
+        }
+        if ((integrator.isZero() || protocol.isZero()) && !fee.isZero()) {
+            throw new Error('fee must be zero if integrator or protocol is zero address');
+        }
+    }
+}
+IntegratorFee.ZERO = new IntegratorFee(Address.ZERO_ADDRESS, Address.ZERO_ADDRESS, Bps.ZERO, Bps.ZERO);

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

@@ -0,0 +1,19 @@
+import { Address } from '../../../address.js';
+import { Bps } from '../../../bps.js';
+/**
+ * Fee paid by resolver to `receiver`
+ */
+export declare class ResolverFee {
+    readonly receiver: Address;
+    readonly fee: Bps;
+    /**
+     * whitelisted resolvers have discount on fee
+     */
+    readonly whitelistDiscount: Bps;
+    static ZERO: ResolverFee;
+    constructor(receiver: Address, fee: Bps, 
+    /**
+     * whitelisted resolvers have discount on fee
+     */
+    whitelistDiscount?: Bps);
+}

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

@@ -0,0 +1,28 @@
+import assert from 'assert';
+import { Address } from '../../../address.js';
+import { Bps } from '../../../bps.js';
+/**
+ * Fee paid by resolver to `receiver`
+ */
+export class ResolverFee {
+    constructor(receiver, fee, 
+    /**
+     * whitelisted resolvers have discount on fee
+     */
+    whitelistDiscount = Bps.ZERO) {
+        this.receiver = receiver;
+        this.fee = fee;
+        this.whitelistDiscount = whitelistDiscount;
+        if (receiver.isZero() && !fee.isZero()) {
+            throw new Error('fee must be zero if receiver is zero address');
+        }
+        if (!receiver.isZero() && fee.isZero()) {
+            throw new Error('receiver must be zero address if fee is zero');
+        }
+        if (fee.isZero() && !whitelistDiscount.isZero()) {
+            throw new Error('whitelist discount must be zero if fee is zero');
+        }
+        assert(this.whitelistDiscount.value % 100n === 0n, `whitelist discount must have percent precision: 1%, 2% and so on`);
+    }
+}
+ResolverFee.ZERO = new ResolverFee(Address.ZERO_ADDRESS, Bps.ZERO);

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

@@ -0,0 +1,4 @@
+import { Address } from '../../../address.js';
+export type Whitelist = {
+    isWhitelisted(taker: Address): boolean;
+};

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

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

package/dist/limit-order/extensions/fee-taker/whitelist-half-address.d.ts

@@ -0,0 +1,18 @@
+import { BytesBuilder } from "@1inch/byte-utils";
+import { Whitelist } from "./types.js";
+import { Address } from "../../../address.js";
+export declare class WhitelistHalfAddress implements Whitelist {
+    /**
+     * Last 10 bytes of addresses
+     */
+    private readonly addresses;
+    constructor(
+    /**
+     * Last 10 bytes of addresses
+     */
+    addresses: string[]);
+    get length(): number;
+    static new(addresses: Address[]): WhitelistHalfAddress;
+    isWhitelisted(address: Address): boolean;
+    encodeTo(builder: BytesBuilder): BytesBuilder;
+}