@stryke-xyz/premarket-sdk 1.0.0

package/dist/limit-order/maker-traits.spec.js

@@ -0,0 +1,102 @@
+import { UINT_160_MAX, UINT_40_MAX } from '@1inch/byte-utils';
+import { MakerTraits } from './maker-traits.js';
+import { Address } from '../address.js';
+describe('MakerTraits', () => {
+    test('allowed sender', () => {
+        const traits = MakerTraits.default();
+        const sender = Address.fromBigInt(1337n);
+        const senderHalf = traits.withAllowedSender(sender).allowedSender();
+        expect(senderHalf).toEqual(sender.toString().slice(-20));
+    });
+    test('nonce', () => {
+        const traits = MakerTraits.default();
+        const nonce = 1n << 10n;
+        traits.withNonce(nonce);
+        expect(traits.nonceOrEpoch()).toEqual(nonce);
+        const big_nonce = 1n << 50n;
+        expect(() => traits.withNonce(big_nonce)).toThrow('to big for mask');
+    });
+    test('expiration', () => {
+        const traits = MakerTraits.default();
+        const expiration = 1000000n;
+        traits.withExpiration(expiration);
+        expect(traits.expiration()).toEqual(expiration);
+    });
+    test('epoch', () => {
+        const traits = MakerTraits.default();
+        const series = 100n;
+        const epoch = 1n;
+        traits.allowPartialFills().allowMultipleFills().withEpoch(series, epoch);
+        expect(traits.series()).toEqual(series);
+        expect(traits.nonceOrEpoch()).toEqual(epoch);
+        expect(traits.isEpochManagerEnabled()).toEqual(true);
+    });
+    test('extension', () => {
+        const traits = MakerTraits.default();
+        expect(traits.hasExtension()).toEqual(false);
+        traits.withExtension();
+        expect(traits.hasExtension()).toEqual(true);
+    });
+    test('partial fills', () => {
+        const traits = MakerTraits.default();
+        expect(traits.isPartialFillAllowed()).toEqual(true);
+        traits.disablePartialFills();
+        expect(traits.isPartialFillAllowed()).toEqual(false);
+        traits.allowPartialFills();
+        expect(traits.isPartialFillAllowed()).toEqual(true);
+    });
+    test('multiple fills', () => {
+        const traits = MakerTraits.default();
+        expect(traits.isMultipleFillsAllowed()).toEqual(false);
+        traits.allowMultipleFills();
+        expect(traits.isMultipleFillsAllowed()).toEqual(true);
+        traits.disableMultipleFills();
+        expect(traits.isMultipleFillsAllowed()).toEqual(false);
+    });
+    test('pre interaction', () => {
+        const traits = MakerTraits.default();
+        expect(traits.hasPreInteraction()).toEqual(false);
+        traits.enablePreInteraction();
+        expect(traits.hasPreInteraction()).toEqual(true);
+        traits.disablePreInteraction();
+        expect(traits.hasPreInteraction()).toEqual(false);
+    });
+    test('post interaction', () => {
+        const traits = MakerTraits.default();
+        expect(traits.hasPostInteraction()).toEqual(false);
+        traits.enablePostInteraction();
+        expect(traits.hasPostInteraction()).toEqual(true);
+        traits.disablePostInteraction();
+        expect(traits.hasPostInteraction()).toEqual(false);
+    });
+    test('permit2', () => {
+        const traits = MakerTraits.default();
+        expect(traits.isPermit2()).toEqual(false);
+        traits.enablePermit2();
+        expect(traits.isPermit2()).toEqual(true);
+        traits.disablePermit2();
+        expect(traits.isPermit2()).toEqual(false);
+    });
+    test('native unwrap', () => {
+        const traits = MakerTraits.default();
+        expect(traits.isNativeUnwrapEnabled()).toEqual(false);
+        traits.enableNativeUnwrap();
+        expect(traits.isNativeUnwrapEnabled()).toEqual(true);
+        traits.disableNativeUnwrap();
+        expect(traits.isNativeUnwrapEnabled()).toEqual(false);
+    });
+    test('all', () => {
+        const traits = MakerTraits.default()
+            .withAllowedSender(Address.fromBigInt(UINT_160_MAX))
+            .allowPartialFills()
+            .allowMultipleFills()
+            .withEpoch(UINT_40_MAX, UINT_40_MAX)
+            .withExpiration(UINT_40_MAX)
+            .withExtension()
+            .enablePermit2()
+            .enableNativeUnwrap()
+            .enablePreInteraction()
+            .enablePostInteraction();
+        expect(traits.asBigInt().toString(16)).toEqual('5f800000000000ffffffffffffffffffffffffffffffffffffffffffffffffff');
+    });
+});

package/dist/limit-order/source-track.d.ts

@@ -0,0 +1 @@
+export declare function injectTrackCode(salt: bigint, source?: string): bigint;

package/dist/limit-order/source-track.js

@@ -0,0 +1,22 @@
+import { add0x, BitMask, BN, isHexString } from '@1inch/byte-utils';
+import { id } from 'ethers';
+const TRACK_CODE_MASK = new BitMask(224n, 256n);
+function getTrackCodeForSource(source) {
+    if (!isHexString(source)) {
+        return createId(source);
+    }
+    if (source.length === 10) {
+        return BigInt(source);
+    }
+    if (source.length === 66) {
+        return BigInt(source.substring(0, 10));
+    }
+    return createId(source);
+}
+function createId(source) {
+    return BigInt(add0x(id(source).slice(0, 10)));
+}
+export function injectTrackCode(salt, source) {
+    const track = source ? getTrackCodeForSource(source) : 0n;
+    return new BN(salt).setMask(TRACK_CODE_MASK, track).value;
+}

package/dist/limit-order/taker-traits.d.ts

@@ -0,0 +1,141 @@
+import { Extension } from './extensions/extension.js';
+import { Interaction } from './interaction.js';
+import { Address } from '../address.js';
+export declare enum AmountMode {
+    /**
+     * Amount provided to fill function treated as `takingAmount` and `makingAmount` calculated based on it
+     */
+    taker = 0,
+    /**
+     * Amount provided to fill function treated as `makingAmount` and `takingAmount` calculated based on it
+     */
+    maker = 1
+}
+/**
+ * TakerTraitsLib
+ * This class defines TakerTraits, which are used to encode the taker's preferences for an order in a single uint256.
+ *
+ * The TakerTraits are structured as follows:
+ * High bits are used for flags
+ * 255 bit `_MAKER_AMOUNT_FLAG`           - If set, the taking amount is calculated based on making amount, otherwise making amount is calculated based on taking amount.
+ * 254 bit `_UNWRAP_WETH_FLAG`            - If set, the WETH will be unwrapped into ETH before sending to taker.
+ * 253 bit `_SKIP_ORDER_PERMIT_FLAG`      - If set, the order skips maker's permit execution.
+ * 252 bit `_USE_PERMIT2_FLAG`            - If set, the order uses the permit2 function for authorization.
+ * 251 bit `_ARGS_HAS_TARGET`             - If set, then first 20 bytes of args are treated as receiver address for maker’s funds transfer.
+ * 224-247 bits `ARGS_EXTENSION_LENGTH`   - The length of the extension calldata in the args.
+ * 200-223 bits `ARGS_INTERACTION_LENGTH` - The length of the interaction calldata in the args.
+ * 0-184 bits                             - The threshold amount (the maximum amount a taker agrees to give in exchange for a making amount).
+ */
+export declare class TakerTraits {
+    private static MAKER_AMOUNT_FLAG;
+    private static UNWRAP_WETH_FLAG;
+    private static SKIP_ORDER_PERMIT_FLAG;
+    private static USE_PERMIT2_FLAG;
+    private static ARGS_HAS_RECEIVER;
+    private static THRESHOLD_MASK;
+    private static ARGS_INTERACTION_LENGTH_MASK;
+    private static ARGS_EXTENSION_LENGTH_MASK;
+    private flags;
+    private receiver?;
+    private extension?;
+    private interaction?;
+    constructor(flag: bigint, data: {
+        receiver?: Address;
+        extension?: Extension;
+        interaction?: Interaction;
+    });
+    static default(): TakerTraits;
+    /**
+     * Returns enabled amount mode, it defines how to treat passed amount in `fillContractOrderArgs` function
+     *
+     * @see AmountMode
+     */
+    getAmountMode(): AmountMode;
+    setAmountMode(mode: AmountMode): this;
+    /**
+     * Is the Wrapped native currency will be unwrapped into Native currency before sending to taker
+     */
+    isNativeUnwrapEnabled(): boolean;
+    /**
+     * Wrapped native currency will be unwrapped into Native currency before sending to taker
+     */
+    enableNativeUnwrap(): this;
+    /**
+     * Wrapped native currency will NOT be unwrapped into Native currency before sending to taker
+     */
+    disableNativeUnwrap(): this;
+    /**
+     * If true, then maker's permit execution is skipped
+     */
+    isOrderPermitSkipped(): boolean;
+    /**
+     * The order skips maker's permit execution
+     */
+    skipOrderPermit(): this;
+    /**
+     * Should use permit2 function for authorization or not
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    isPermit2Enabled(): boolean;
+    /**
+     * Use permit2 function for authorization
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    enablePermit2(): this;
+    /**
+     * NOT use permit2 function for authorization
+     */
+    disablePermit2(): this;
+    /**
+     * Sets address where order filled to, `msg.sender` used if not set
+     *
+     * @param receiver
+     */
+    setReceiver(receiver: Address): this;
+    /**
+     * Set order receiver as `msg.sender`
+     */
+    removeReceiver(): this;
+    /**
+     * Sets extension, it is required to provide same extension as in order creation (if any)
+     */
+    setExtension(ext: Extension): this;
+    removeExtension(): this;
+    /**
+     * Set threshold amount
+     *
+     * In taker amount mode: the minimum amount a taker agrees to receive in exchange for a taking amount.
+     * In maker amount mode: the maximum amount a taker agrees to give in exchange for a making amount.
+     *
+     * @see AmountMode
+     */
+    setAmountThreshold(threshold: bigint): this;
+    /**
+     * Get threshold amount
+     *
+     * In taker amount mode: the minimum amount a taker agrees to receive in exchange for a taking amount.
+     * In maker amount mode: the maximum amount a taker agrees to give in exchange for a making amount.
+     *
+     * @see AmountMode
+     */
+    getAmountThreshold(): bigint;
+    /**
+     * @see setAmountThreshold
+     */
+    removeAmountThreshold(): this;
+    /**
+     * Sets taker interaction
+     *
+     * `interaction.target` should implement `ITakerInteraction` interface
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/1a32e059f78ddcf1fe6294baed6cafb73a04b685/contracts/interfaces/ITakerInteraction.sol#L11
+     */
+    setInteraction(interaction: Interaction): this;
+    removeInteraction(): this;
+    encode(): {
+        trait: bigint;
+        args: string;
+    };
+}

package/dist/limit-order/taker-traits.js

@@ -0,0 +1,207 @@
+import { BitMask, BN, getBytesCount, trim0x } from '@1inch/byte-utils';
+import { ZX } from '../constants.js';
+export var AmountMode;
+(function (AmountMode) {
+    /**
+     * Amount provided to fill function treated as `takingAmount` and `makingAmount` calculated based on it
+     */
+    AmountMode[AmountMode["taker"] = 0] = "taker";
+    /**
+     * Amount provided to fill function treated as `makingAmount` and `takingAmount` calculated based on it
+     */
+    AmountMode[AmountMode["maker"] = 1] = "maker";
+})(AmountMode || (AmountMode = {}));
+/**
+ * TakerTraitsLib
+ * This class defines TakerTraits, which are used to encode the taker's preferences for an order in a single uint256.
+ *
+ * The TakerTraits are structured as follows:
+ * High bits are used for flags
+ * 255 bit `_MAKER_AMOUNT_FLAG`           - If set, the taking amount is calculated based on making amount, otherwise making amount is calculated based on taking amount.
+ * 254 bit `_UNWRAP_WETH_FLAG`            - If set, the WETH will be unwrapped into ETH before sending to taker.
+ * 253 bit `_SKIP_ORDER_PERMIT_FLAG`      - If set, the order skips maker's permit execution.
+ * 252 bit `_USE_PERMIT2_FLAG`            - If set, the order uses the permit2 function for authorization.
+ * 251 bit `_ARGS_HAS_TARGET`             - If set, then first 20 bytes of args are treated as receiver address for maker’s funds transfer.
+ * 224-247 bits `ARGS_EXTENSION_LENGTH`   - The length of the extension calldata in the args.
+ * 200-223 bits `ARGS_INTERACTION_LENGTH` - The length of the interaction calldata in the args.
+ * 0-184 bits                             - The threshold amount (the maximum amount a taker agrees to give in exchange for a making amount).
+ */
+export class TakerTraits {
+    constructor(flag, data) {
+        this.flags = new BN(flag);
+        this.receiver = data.receiver;
+        this.extension = data.extension;
+        this.interaction = data.interaction;
+    }
+    static default() {
+        return new TakerTraits(0n, {});
+    }
+    /**
+     * Returns enabled amount mode, it defines how to treat passed amount in `fillContractOrderArgs` function
+     *
+     * @see AmountMode
+     */
+    getAmountMode() {
+        return this.flags.getBit(TakerTraits.MAKER_AMOUNT_FLAG);
+    }
+    setAmountMode(mode) {
+        this.flags = this.flags.setBit(TakerTraits.MAKER_AMOUNT_FLAG, mode);
+        return this;
+    }
+    /**
+     * Is the Wrapped native currency will be unwrapped into Native currency before sending to taker
+     */
+    isNativeUnwrapEnabled() {
+        return this.flags.getBit(TakerTraits.UNWRAP_WETH_FLAG) === 1;
+    }
+    /**
+     * Wrapped native currency will be unwrapped into Native currency before sending to taker
+     */
+    enableNativeUnwrap() {
+        this.flags = this.flags.setBit(TakerTraits.UNWRAP_WETH_FLAG, 1);
+        return this;
+    }
+    /**
+     * Wrapped native currency will NOT be unwrapped into Native currency before sending to taker
+     */
+    disableNativeUnwrap() {
+        this.flags = this.flags.setBit(TakerTraits.UNWRAP_WETH_FLAG, 0);
+        return this;
+    }
+    /**
+     * If true, then maker's permit execution is skipped
+     */
+    isOrderPermitSkipped() {
+        return Boolean(this.flags.getBit(TakerTraits.SKIP_ORDER_PERMIT_FLAG));
+    }
+    /**
+     * The order skips maker's permit execution
+     */
+    skipOrderPermit() {
+        this.flags = this.flags.setBit(TakerTraits.SKIP_ORDER_PERMIT_FLAG, 1);
+        return this;
+    }
+    /**
+     * Should use permit2 function for authorization or not
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    isPermit2Enabled() {
+        return this.flags.getBit(TakerTraits.USE_PERMIT2_FLAG) === 1;
+    }
+    /**
+     * Use permit2 function for authorization
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    enablePermit2() {
+        this.flags = this.flags.setBit(TakerTraits.USE_PERMIT2_FLAG, 1);
+        return this;
+    }
+    /**
+     * NOT use permit2 function for authorization
+     */
+    disablePermit2() {
+        this.flags = this.flags.setBit(TakerTraits.USE_PERMIT2_FLAG, 0);
+        return this;
+    }
+    /**
+     * Sets address where order filled to, `msg.sender` used if not set
+     *
+     * @param receiver
+     */
+    setReceiver(receiver) {
+        this.receiver = receiver;
+        return this;
+    }
+    /**
+     * Set order receiver as `msg.sender`
+     */
+    removeReceiver() {
+        this.receiver = undefined;
+        return this;
+    }
+    /**
+     * Sets extension, it is required to provide same extension as in order creation (if any)
+     */
+    setExtension(ext) {
+        this.extension = ext;
+        return this;
+    }
+    removeExtension() {
+        this.extension = undefined;
+        return this;
+    }
+    /**
+     * Set threshold amount
+     *
+     * In taker amount mode: the minimum amount a taker agrees to receive in exchange for a taking amount.
+     * In maker amount mode: the maximum amount a taker agrees to give in exchange for a making amount.
+     *
+     * @see AmountMode
+     */
+    setAmountThreshold(threshold) {
+        this.flags = this.flags.setMask(TakerTraits.THRESHOLD_MASK, threshold);
+        return this;
+    }
+    /**
+     * Get threshold amount
+     *
+     * In taker amount mode: the minimum amount a taker agrees to receive in exchange for a taking amount.
+     * In maker amount mode: the maximum amount a taker agrees to give in exchange for a making amount.
+     *
+     * @see AmountMode
+     */
+    getAmountThreshold() {
+        return this.flags.getMask(TakerTraits.THRESHOLD_MASK).value;
+    }
+    /**
+     * @see setAmountThreshold
+     */
+    removeAmountThreshold() {
+        this.flags = this.flags.setMask(TakerTraits.THRESHOLD_MASK, 0n);
+        return this;
+    }
+    /**
+     * Sets taker interaction
+     *
+     * `interaction.target` should implement `ITakerInteraction` interface
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/1a32e059f78ddcf1fe6294baed6cafb73a04b685/contracts/interfaces/ITakerInteraction.sol#L11
+     */
+    setInteraction(interaction) {
+        this.interaction = interaction;
+        return this;
+    }
+    removeInteraction() {
+        this.interaction = undefined;
+        return this;
+    }
+    encode() {
+        const extensionLen = this.extension
+            ? getBytesCount(this.extension.encode())
+            : 0n;
+        const interactionLen = this.interaction
+            ? getBytesCount(this.interaction.encode())
+            : 0n;
+        const flags = this.flags
+            .setBit(TakerTraits.ARGS_HAS_RECEIVER, this.receiver ? 1 : 0)
+            .setMask(TakerTraits.ARGS_EXTENSION_LENGTH_MASK, extensionLen)
+            .setMask(TakerTraits.ARGS_INTERACTION_LENGTH_MASK, interactionLen);
+        const args = (this.receiver?.toString() || ZX) +
+            trim0x(this.extension?.encode() || '') +
+            trim0x(this.interaction?.encode() || '');
+        return {
+            trait: flags.value,
+            args
+        };
+    }
+}
+TakerTraits.MAKER_AMOUNT_FLAG = 255n;
+TakerTraits.UNWRAP_WETH_FLAG = 254n;
+TakerTraits.SKIP_ORDER_PERMIT_FLAG = 253n;
+TakerTraits.USE_PERMIT2_FLAG = 252n;
+TakerTraits.ARGS_HAS_RECEIVER = 251n;
+TakerTraits.THRESHOLD_MASK = new BitMask(0n, 185n);
+TakerTraits.ARGS_INTERACTION_LENGTH_MASK = new BitMask(200n, 224n);
+TakerTraits.ARGS_EXTENSION_LENGTH_MASK = new BitMask(224n, 248n);

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

@@ -0,0 +1,24 @@
+import { Extension } from './extensions/extension.js';
+import { Address } from '../address.js';
+export type OrderInfoData = {
+    makerAsset: Address;
+    takerAsset: Address;
+    makingAmount: bigint;
+    takingAmount: bigint;
+    maker: Address;
+    salt?: bigint;
+    receiver?: Address;
+};
+export type LimitOrderV4Struct = {
+    salt: string;
+    maker: string;
+    receiver: string;
+    makerAsset: string;
+    takerAsset: string;
+    makingAmount: string;
+    takingAmount: string;
+    makerTraits: string;
+};
+export interface IExtensionBuilder {
+    build(): Extension;
+}

package/dist/limit-order/types.js

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

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

@@ -0,0 +1,16 @@
+/**
+ * Validate maker traits - require:
+ * - HAS_EXTENSION_FLAG (bit 249) must be set
+ * - ALLOW_MULTIPLE_FILLS_FLAG (bit 254) must be set
+ * - NO_PARTIAL_FILLS_FLAG (bit 255) must NOT be set (partial fills must be allowed)
+ * - Nonce is required
+ * - Expiration is optional
+ * - All other flags must be unset
+ */
+export declare function validateMakerTraits(makerTraitsHex: string): void;
+/**
+ * Validate extension - for ERC6909 orders:
+ * - Sell orders (SELL_OPTIONS): makerAssetSuffix required, takerAssetSuffix must be empty
+ * - Buy orders (BUY_OPTIONS): takerAssetSuffix required, makerAssetSuffix must be empty
+ */
+export declare function validateExtension(extensionEncoded: string, orderType: "SELL_OPTIONS" | "BUY_OPTIONS"): void;

package/dist/limit-order/verification.js

@@ -0,0 +1,108 @@
+import { Extension } from "./extensions/extension";
+/**
+ * Validate maker traits - require:
+ * - HAS_EXTENSION_FLAG (bit 249) must be set
+ * - ALLOW_MULTIPLE_FILLS_FLAG (bit 254) must be set
+ * - NO_PARTIAL_FILLS_FLAG (bit 255) must NOT be set (partial fills must be allowed)
+ * - Nonce is required
+ * - Expiration is optional
+ * - All other flags must be unset
+ */
+export function validateMakerTraits(makerTraitsHex) {
+    const traits = BigInt(makerTraitsHex);
+    // Bit masks for allowed features
+    const HAS_EXTENSION_FLAG = 1n << 249n;
+    const NONCE_MASK = (1n << 40n) - 1n; // bits 120-160 (40 bits)
+    const ALLOWED_SENDER_MASK = (1n << 80n) - 1n; // bits 0-80 (80 bits)
+    // Extract low 200 bits (allowed sender, expiration, nonce, series)
+    const lowBits = traits & ((1n << 200n) - 1n);
+    // Check that HAS_EXTENSION_FLAG is set (required)
+    if ((traits & HAS_EXTENSION_FLAG) === 0n) {
+        throw new Error("Invalid maker traits: HAS_EXTENSION_FLAG (bit 249) is required");
+    }
+    // Check that ALLOW_MULTIPLE_FILLS_FLAG is set (bit 254 = 1)
+    const ALLOW_MULTIPLE_FILLS_FLAG = 1n << 254n;
+    if ((traits & ALLOW_MULTIPLE_FILLS_FLAG) === 0n) {
+        throw new Error("Invalid maker traits: ALLOW_MULTIPLE_FILLS_FLAG (bit 254) must be set");
+    }
+    // Check that NO_PARTIAL_FILLS_FLAG is NOT set (bit 255 = 0)
+    const NO_PARTIAL_FILLS_FLAG = 1n << 255n;
+    if ((traits & NO_PARTIAL_FILLS_FLAG) !== 0n) {
+        throw new Error("Invalid maker traits: NO_PARTIAL_FILLS_FLAG (bit 255) must not be set (partial fills must be allowed)");
+    }
+    // Check that no other forbidden high bits are set (bits 247-253, except 249 and 254)
+    const forbiddenFlags = (1n << 253n) | // unused
+        (1n << 252n) | // PRE_INTERACTION_CALL_FLAG
+        (1n << 251n) | // POST_INTERACTION_CALL_FLAG
+        (1n << 250n) | // NEED_CHECK_EPOCH_MANAGER_FLAG
+        (1n << 248n) | // USE_PERMIT2_FLAG
+        (1n << 247n); // UNWRAP_WETH_FLAG
+    if ((traits & forbiddenFlags) !== 0n) {
+        throw new Error(`Invalid maker traits: forbidden flags detected. Only HAS_EXTENSION_FLAG (bit 249) and ALLOW_MULTIPLE_FILLS_FLAG (bit 254) are allowed in high bits`);
+    }
+    // Low 200 bits can have: allowedSender (must be 0), expiration (optional), nonce (required), series (must be 0)
+    const series = (lowBits >> 160n) & ((1n << 40n) - 1n);
+    if (series !== 0n) {
+        throw new Error("Invalid maker traits: series must be 0");
+    }
+    const nonce = (lowBits >> 120n) & NONCE_MASK;
+    if (nonce === 0n) {
+        throw new Error("Invalid maker traits: nonce is required");
+    }
+    // Expiration is optional (can be 0)
+    // Allowed sender must be 0
+    const allowedSender = lowBits & ALLOWED_SENDER_MASK;
+    if (allowedSender !== 0n) {
+        throw new Error("Invalid maker traits: allowedSender must be 0");
+    }
+}
+/**
+ * Validate extension - for ERC6909 orders:
+ * - Sell orders (SELL_OPTIONS): makerAssetSuffix required, takerAssetSuffix must be empty
+ * - Buy orders (BUY_OPTIONS): takerAssetSuffix required, makerAssetSuffix must be empty
+ */
+export function validateExtension(extensionEncoded, orderType) {
+    const extension = Extension.decode(extensionEncoded);
+    // Check that forbidden fields are empty
+    if (extension.makingAmountData !== "0x") {
+        throw new Error("Invalid extension: makingAmountData must be empty");
+    }
+    if (extension.takingAmountData !== "0x") {
+        throw new Error("Invalid extension: takingAmountData must be empty");
+    }
+    if (extension.predicate !== "0x") {
+        throw new Error("Invalid extension: predicate must be empty");
+    }
+    if (extension.makerPermit !== "0x") {
+        throw new Error("Invalid extension: makerPermit must be empty");
+    }
+    if (extension.preInteraction !== "0x") {
+        throw new Error("Invalid extension: preInteraction must be empty");
+    }
+    if (extension.postInteraction !== "0x") {
+        throw new Error("Invalid extension: postInteraction must be empty");
+    }
+    if (extension.customData !== "0x") {
+        throw new Error("Invalid extension: customData must be empty");
+    }
+    const hasMakerSuffix = extension.makerAssetSuffix !== "0x";
+    const hasTakerSuffix = extension.takerAssetSuffix !== "0x";
+    if (orderType === "SELL_OPTIONS") {
+        // Sell: maker gives options, so makerAssetSuffix required
+        if (!hasMakerSuffix) {
+            throw new Error("Invalid extension for SELL_OPTIONS: makerAssetSuffix is required");
+        }
+        if (hasTakerSuffix) {
+            throw new Error("Invalid extension for SELL_OPTIONS: takerAssetSuffix must be empty");
+        }
+    }
+    else {
+        // Buy: taker gives options, so takerAssetSuffix required
+        if (!hasTakerSuffix) {
+            throw new Error("Invalid extension for BUY_OPTIONS: takerAssetSuffix is required");
+        }
+        if (hasMakerSuffix) {
+            throw new Error("Invalid extension for BUY_OPTIONS: makerAssetSuffix must be empty");
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './limit-order-contract.js';
+export * from './native-order-factory.js';
+export * from './native-order-impl.js';
+export * from './proxy-factory.js';

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

@@ -0,0 +1,4 @@
+export * from './limit-order-contract.js';
+export * from './native-order-factory.js';
+export * from './native-order-impl.js';
+export * from './proxy-factory.js';

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

@@ -0,0 +1,34 @@
+import { LimitOrderV4Struct, TakerTraits } from '../limit-order/index.js';
+/**
+ * @see https://github.com/1inch/limit-order-protocol/blob/3169ea46932ef44114a215a60d1d91ef022b416d/contracts/OrderMixin.sol#L27
+ */
+export declare class LimitOrderContract {
+    /**
+     *  Fill order WITHOUT an extension and taker interaction
+     *
+     *  @see getFillOrderArgsCalldata
+     *  @see getFillContractOrderCalldata
+     */
+    static getFillOrderCalldata(order: LimitOrderV4Struct, signature: string, takerTraits: TakerTraits, amount: bigint): string;
+    /**
+     *  Fill contract order (order maker is smart-contract) WITHOUT an extension and taker interaction
+     *
+     *  @see getFillContractOrderArgsCalldata
+     *  @see getFillOrderCalldata
+     */
+    static getFillContractOrderCalldata(order: LimitOrderV4Struct, signature: string, takerTraits: TakerTraits, amount: bigint): string;
+    /**
+     *  Fill order WITH an extension or taker interaction
+     *
+     *  @see getFillOrderCalldata
+     *  @see getFillContractOrderArgsCalldata
+     */
+    static getFillOrderArgsCalldata(order: LimitOrderV4Struct, signature: string, takerTraits: TakerTraits, amount: bigint): string;
+    /**
+     *  Fill contract order (order maker is smart-contract) WITH an extension or taker interaction
+     *
+     *  @see getFillOrderArgsCalldata
+     *  @see getFillContractOrderCalldata
+     */
+    static getFillContractOrderArgsCalldata(order: LimitOrderV4Struct, signature: string, takerTraits: TakerTraits, amount: bigint): string;
+}