@stryke-xyz/premarket-sdk 1.0.0

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

@@ -0,0 +1,103 @@
+import { LimitOrder } from './limit-order.js';
+import { ExtensionBuilder } from './extensions/extension-builder.js';
+import { MakerTraits } from './maker-traits.js';
+import { Extension } from './extensions/index.js';
+import { Address } from '../address.js';
+import { ProxyFactory } from '../limit-order-contract/index.js';
+describe('Limit Order', () => {
+    jest.spyOn(Math, 'random').mockReturnValue(1);
+    jest.spyOn(Date, 'now').mockReturnValue(1673549418040);
+    it('should create limit order', () => {
+        const order = new LimitOrder({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa')
+        });
+        expect(order.receiver).toEqual(Address.ZERO_ADDRESS);
+        expect(LimitOrder.fromCalldata(order.toCalldata())).toEqual(order);
+    });
+    it('should create limit order and set receiver == maker', () => {
+        const ext = new ExtensionBuilder().build();
+        const order = new LimitOrder({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa'),
+            salt: LimitOrder.buildSalt(ext)
+        }, MakerTraits.default(), ext, { optimizeReceiverAddress: false });
+        expect(order.receiver).toEqual(order.maker);
+        expect(LimitOrder.fromCalldata(order.toCalldata())).toEqual(order);
+        expect(LimitOrder.fromDataAndExtension(order.build(), ext)).toEqual(order);
+    });
+    it('should create limit order with passed salt', () => {
+        const order = new LimitOrder({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa'),
+            salt: 10n
+        });
+        expect(LimitOrder.fromCalldata(order.toCalldata())).toEqual(order);
+    });
+    it('should create limit order with extension and salt', () => {
+        const ext = new ExtensionBuilder().withCustomData('0xdeadbeef').build();
+        const order = new LimitOrder({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa'),
+            salt: LimitOrder.buildSalt(ext)
+        }, MakerTraits.default(), ext);
+        expect(LimitOrder.fromDataAndExtension(order.build(), ext)).toEqual(order);
+    });
+});
+describe('Limit Order Native', () => {
+    jest.spyOn(Math, 'random').mockReturnValue(1);
+    jest.spyOn(Date, 'now').mockReturnValue(1673549418040);
+    it('should correct detect that order is from native asset', () => {
+        const nativeOrderFactory = new ProxyFactory(Address.fromBigInt(228n), Address.fromBigInt(2n));
+        const maker = new Address('0x00000000219ab540356cbb839cbe05303d7705fa');
+        const nativeOrder = LimitOrder.fromNative(1, nativeOrderFactory, {
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker,
+            salt: 10n
+        }, MakerTraits.default().withExtension(), Extension.default());
+        expect(nativeOrder.receiver).toEqual(maker);
+        expect(nativeOrder.isNative(1, nativeOrderFactory, nativeOrder.nativeSignature(maker))).toEqual(true);
+        expect(LimitOrder.fromDataAndExtension(nativeOrder.build(), nativeOrder.extension).isNative(1, nativeOrderFactory, nativeOrder.nativeSignature(maker))).toEqual(true);
+    });
+    it('should correct detect that order is from native asset (no salt)', () => {
+        const nativeOrderFactory = new ProxyFactory(Address.fromBigInt(228n), Address.fromBigInt(2n));
+        const maker = new Address('0x00000000219ab540356cbb839cbe05303d7705fa');
+        const nativeOrder = LimitOrder.fromNative(1, nativeOrderFactory, {
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker
+        }, MakerTraits.default().withExtension(), Extension.default());
+        expect(nativeOrder.receiver).toEqual(maker);
+        expect(nativeOrder.isNative(1, nativeOrderFactory, nativeOrder.nativeSignature(maker))).toEqual(true);
+        expect(LimitOrder.fromDataAndExtension(nativeOrder.build(), nativeOrder.extension).isNative(1, nativeOrderFactory, nativeOrder.nativeSignature(maker))).toEqual(true);
+    });
+    it('should correct detect that order is NOT from native asset', () => {
+        const nativeOrderFactory = new ProxyFactory(Address.fromBigInt(228n), Address.fromBigInt(2n));
+        const maker = new Address('0x00000000219ab540356cbb839cbe05303d7705fa');
+        const order = new LimitOrder({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker
+        });
+        expect(order.receiver).toEqual(Address.ZERO_ADDRESS);
+        expect(order.isNative(1, nativeOrderFactory, order.nativeSignature(maker))).toEqual(false);
+        expect(LimitOrder.fromDataAndExtension(order.build(), order.extension).isNative(1, nativeOrderFactory, order.nativeSignature(maker))).toEqual(false);
+    });
+});

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

@@ -0,0 +1,200 @@
+import { Address } from '../address.js';
+/**
+ * The MakerTraits type is an uint256, and different parts of the number are used to encode different traits.
+ * High bits are used for flags
+ * 255 bit `NO_PARTIAL_FILLS_FLAG`          - if set, the order does not allow partial fills
+ * 254 bit `ALLOW_MULTIPLE_FILLS_FLAG`      - if set, the order permits multiple fills
+ * 253 bit                                  - unused
+ * 252 bit `PRE_INTERACTION_CALL_FLAG`      - if set, the order requires pre-interaction call
+ * 251 bit `POST_INTERACTION_CALL_FLAG`     - if set, the order requires post-interaction call
+ * 250 bit `NEED_CHECK_EPOCH_MANAGER_FLAG`  - if set, the order requires to check the epoch manager
+ * 249 bit `HAS_EXTENSION_FLAG`             - if set, the order has extension(s)
+ * 248 bit `USE_PERMIT2_FLAG`               - if set, the order uses permit2
+ * 247 bit `UNWRAP_WETH_FLAG`               - if set, the order requires to unwrap WETH
+ *
+ * Low 200 bits are used for allowed sender, expiration, nonceOrEpoch, and series
+ * uint80 last 10 bytes of allowed sender address (0 if any)
+ * uint40 expiration timestamp (0 if none)
+ * uint40 nonce or epoch
+ * uint40 series
+ */
+export declare class MakerTraits {
+    private static ALLOWED_SENDER_MASK;
+    private static EXPIRATION_MASK;
+    private static NONCE_OR_EPOCH_MASK;
+    private static SERIES_MASK;
+    private static NO_PARTIAL_FILLS_FLAG;
+    private static ALLOW_MULTIPLE_FILLS_FLAG;
+    private static PRE_INTERACTION_CALL_FLAG;
+    private static POST_INTERACTION_CALL_FLAG;
+    private static NEED_CHECK_EPOCH_MANAGER_FLAG;
+    private static HAS_EXTENSION_FLAG;
+    private static USE_PERMIT2_FLAG;
+    private static UNWRAP_WETH_FLAG;
+    private value;
+    constructor(val: bigint);
+    static default(): MakerTraits;
+    /**
+     * Last 10bytes of address
+     */
+    allowedSender(): string;
+    isPrivate(): boolean;
+    withAllowedSender(sender: Address): this;
+    /**
+     * Removes `sender` check on contract
+     */
+    withAnySender(): this;
+    /**
+     * If null is return than order has no expiration
+     */
+    expiration(): bigint | null;
+    /**
+     * Set order expiration time
+     *
+     * @param expiration expiration timestamp in sec
+     */
+    withExpiration(expiration: bigint): this;
+    /**
+     * Returns epoch in case `isEpochManagerEnabled()` and nonce otherwise
+     */
+    nonceOrEpoch(): bigint;
+    /**
+     * Set nonce
+     * Note: nonce and epoch share the same field, so they cant be set together
+     * @param nonce must be less or equal to `uint40::max`
+     */
+    withNonce(nonce: bigint): this;
+    /**
+     * Enable epoch manager check
+     *
+     * If set, the contract will check that order epoch equals to epoch on `SeriesEpochManager` contract
+     * Note: epoch manager can be used only when `partialFills` AND `multipleFills` allowed
+     * Note: nonce and epoch share the same field, so they cant be set together
+     *
+     * @param series subgroup for epoch
+     * @param epoch unique order id inside series
+     * @see https://github.com/1inch/limit-order-protocol/blob/23d655844191dea7960a186652307604a1ed480a/contracts/helpers/SeriesEpochManager.sol#L6
+     */
+    withEpoch(series: bigint, epoch: bigint): this;
+    /**
+     * Get current series
+     */
+    series(): bigint;
+    /**
+     * Returns true if order has an extension and false otherwise
+     */
+    hasExtension(): boolean;
+    /**
+     * Mark that order has an extension
+     */
+    withExtension(): this;
+    /**
+     * Is partial fills allowed for order
+     */
+    isPartialFillAllowed(): boolean;
+    /**
+     * Disable partial fills for order
+     */
+    disablePartialFills(): this;
+    /**
+     * Allow partial fills for order
+     */
+    allowPartialFills(): this;
+    /**
+     * Set partial fill flag to passed value
+     */
+    setPartialFills(val: boolean): this;
+    /**
+     * Returns true if order allowing more than one fill and false otherwise
+     */
+    isMultipleFillsAllowed(): boolean;
+    /**
+     * Allow many fills for order
+     */
+    allowMultipleFills(): this;
+    /**
+     * Allow at max 1 fill for order
+     */
+    disableMultipleFills(): this;
+    /**
+     * If `val` is true, then multiple fills allowed, otherwise disallowed
+     */
+    setMultipleFills(val: boolean): this;
+    /**
+     * Returns true if maker has pre-interaction and false otherwise
+     */
+    hasPreInteraction(): boolean;
+    /**
+     * Enable maker pre-interaction
+     */
+    enablePreInteraction(): this;
+    /**
+     * Disable maker pre-interaction
+     */
+    disablePreInteraction(): this;
+    /**
+     * Returns true if maker has post-interaction and false otherwise
+     */
+    hasPostInteraction(): boolean;
+    /**
+     * Enable maker post-interaction
+     */
+    enablePostInteraction(): this;
+    /**
+     * Disable maker post-interaction
+     */
+    disablePostInteraction(): this;
+    /**
+     * Returns true if epoch manager enabled
+     *
+     * @see MakerTraits.enableEpochManagerCheck
+     */
+    isEpochManagerEnabled(): boolean;
+    /**
+     * Returns true if `permit2` enabled for maker funds transfer
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    isPermit2(): boolean;
+    /**
+     * Use `permit2` to transfer maker funds to contract
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    enablePermit2(): this;
+    /**
+     * Do not use `permit2` to transfer maker funds to contract
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    disablePermit2(): this;
+    /**
+     * Is WRAPPED token will be unwrapped to NATIVE before sending to maker
+     */
+    isNativeUnwrapEnabled(): boolean;
+    /**
+     * Unwrap WRAPPED token to NATIVE before sending it to maker
+     */
+    enableNativeUnwrap(): this;
+    /**
+     * Do not unwrap WRAPPED token to NATIVE before sending it to maker
+     */
+    disableNativeUnwrap(): this;
+    asBigInt(): bigint;
+    /**
+     * Returns true if bit invalidator mode is used to invalidate order (cancel/mark as filled)
+     *
+     * Bit invalidator is cheaper in terms of gas, but can be used only when partial fills OR multiple fills are disabled
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/3c9b8ab8bbc4c10ff8d615fc3d33f501993c292d/contracts/libraries/MakerTraitsLib.sol#L142
+     */
+    isBitInvalidatorMode(): boolean;
+    private enableEpochManagerCheck;
+    /**
+     * Set series. Only when epoch manager enabled
+     * Series is a subgroup for epoch's, it can be useful when you want to cancel a group of orders at once
+     *
+     * @see MakerTraits.enableEpochManagerCheck
+     */
+    private setSeries;
+}

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

@@ -0,0 +1,309 @@
+import { add0x, BitMask, BN } from '@1inch/byte-utils';
+import assert from 'assert';
+/**
+ * The MakerTraits type is an uint256, and different parts of the number are used to encode different traits.
+ * High bits are used for flags
+ * 255 bit `NO_PARTIAL_FILLS_FLAG`          - if set, the order does not allow partial fills
+ * 254 bit `ALLOW_MULTIPLE_FILLS_FLAG`      - if set, the order permits multiple fills
+ * 253 bit                                  - unused
+ * 252 bit `PRE_INTERACTION_CALL_FLAG`      - if set, the order requires pre-interaction call
+ * 251 bit `POST_INTERACTION_CALL_FLAG`     - if set, the order requires post-interaction call
+ * 250 bit `NEED_CHECK_EPOCH_MANAGER_FLAG`  - if set, the order requires to check the epoch manager
+ * 249 bit `HAS_EXTENSION_FLAG`             - if set, the order has extension(s)
+ * 248 bit `USE_PERMIT2_FLAG`               - if set, the order uses permit2
+ * 247 bit `UNWRAP_WETH_FLAG`               - if set, the order requires to unwrap WETH
+ *
+ * Low 200 bits are used for allowed sender, expiration, nonceOrEpoch, and series
+ * uint80 last 10 bytes of allowed sender address (0 if any)
+ * uint40 expiration timestamp (0 if none)
+ * uint40 nonce or epoch
+ * uint40 series
+ */
+export class MakerTraits {
+    constructor(val) {
+        this.value = new BN(val);
+    }
+    static default() {
+        return new MakerTraits(0n);
+    }
+    /**
+     * Last 10bytes of address
+     */
+    allowedSender() {
+        return this.value
+            .getMask(MakerTraits.ALLOWED_SENDER_MASK)
+            .value.toString(16)
+            .padStart(20, '0');
+    }
+    isPrivate() {
+        return this.value.getMask(MakerTraits.ALLOWED_SENDER_MASK).value !== 0n;
+    }
+    withAllowedSender(sender) {
+        assert(!sender.isZero(), 'Use withAnySender() to remove sender check');
+        const lastHalf = add0x(sender.toString().slice(-20));
+        this.value = this.value.setMask(MakerTraits.ALLOWED_SENDER_MASK, BigInt(lastHalf));
+        return this;
+    }
+    /**
+     * Removes `sender` check on contract
+     */
+    withAnySender() {
+        this.value = this.value.setMask(MakerTraits.ALLOWED_SENDER_MASK, BigInt(0));
+        return this;
+    }
+    /**
+     * If null is return than order has no expiration
+     */
+    expiration() {
+        const timestampSec = this.value.getMask(MakerTraits.EXPIRATION_MASK);
+        if (timestampSec.isZero()) {
+            return null;
+        }
+        return timestampSec.value;
+    }
+    /**
+     * Set order expiration time
+     *
+     * @param expiration expiration timestamp in sec
+     */
+    withExpiration(expiration) {
+        const expirationSec = expiration === null ? 0n : expiration;
+        this.value = this.value.setMask(MakerTraits.EXPIRATION_MASK, expirationSec);
+        return this;
+    }
+    /**
+     * Returns epoch in case `isEpochManagerEnabled()` and nonce otherwise
+     */
+    nonceOrEpoch() {
+        return this.value.getMask(MakerTraits.NONCE_OR_EPOCH_MASK).value;
+    }
+    /**
+     * Set nonce
+     * Note: nonce and epoch share the same field, so they cant be set together
+     * @param nonce must be less or equal to `uint40::max`
+     */
+    withNonce(nonce) {
+        this.value = this.value.setMask(MakerTraits.NONCE_OR_EPOCH_MASK, nonce);
+        return this;
+    }
+    /**
+     * Enable epoch manager check
+     *
+     * If set, the contract will check that order epoch equals to epoch on `SeriesEpochManager` contract
+     * Note: epoch manager can be used only when `partialFills` AND `multipleFills` allowed
+     * Note: nonce and epoch share the same field, so they cant be set together
+     *
+     * @param series subgroup for epoch
+     * @param epoch unique order id inside series
+     * @see https://github.com/1inch/limit-order-protocol/blob/23d655844191dea7960a186652307604a1ed480a/contracts/helpers/SeriesEpochManager.sol#L6
+     */
+    withEpoch(series, epoch) {
+        this.setSeries(series);
+        this.enableEpochManagerCheck();
+        return this.withNonce(epoch);
+    }
+    /**
+     * Get current series
+     */
+    series() {
+        return this.value.getMask(MakerTraits.SERIES_MASK).value;
+    }
+    /**
+     * Returns true if order has an extension and false otherwise
+     */
+    hasExtension() {
+        return this.value.getBit(MakerTraits.HAS_EXTENSION_FLAG) === 1;
+    }
+    /**
+     * Mark that order has an extension
+     */
+    withExtension() {
+        this.value = this.value.setBit(MakerTraits.HAS_EXTENSION_FLAG, 1);
+        return this;
+    }
+    /**
+     * Is partial fills allowed for order
+     */
+    isPartialFillAllowed() {
+        return this.value.getBit(MakerTraits.NO_PARTIAL_FILLS_FLAG) === 0;
+    }
+    /**
+     * Disable partial fills for order
+     */
+    disablePartialFills() {
+        this.value = this.value.setBit(MakerTraits.NO_PARTIAL_FILLS_FLAG, 1);
+        return this;
+    }
+    /**
+     * Allow partial fills for order
+     */
+    allowPartialFills() {
+        this.value = this.value.setBit(MakerTraits.NO_PARTIAL_FILLS_FLAG, 0);
+        return this;
+    }
+    /**
+     * Set partial fill flag to passed value
+     */
+    setPartialFills(val) {
+        return val ? this.allowPartialFills() : this.disablePartialFills();
+    }
+    /**
+     * Returns true if order allowing more than one fill and false otherwise
+     */
+    isMultipleFillsAllowed() {
+        return this.value.getBit(MakerTraits.ALLOW_MULTIPLE_FILLS_FLAG) === 1;
+    }
+    /**
+     * Allow many fills for order
+     */
+    allowMultipleFills() {
+        this.value = this.value.setBit(MakerTraits.ALLOW_MULTIPLE_FILLS_FLAG, 1);
+        return this;
+    }
+    /**
+     * Allow at max 1 fill for order
+     */
+    disableMultipleFills() {
+        this.value = this.value.setBit(MakerTraits.ALLOW_MULTIPLE_FILLS_FLAG, 0);
+        return this;
+    }
+    /**
+     * If `val` is true, then multiple fills allowed, otherwise disallowed
+     */
+    setMultipleFills(val) {
+        return val ? this.allowMultipleFills() : this.disableMultipleFills();
+    }
+    /**
+     * Returns true if maker has pre-interaction and false otherwise
+     */
+    hasPreInteraction() {
+        return this.value.getBit(MakerTraits.PRE_INTERACTION_CALL_FLAG) === 1;
+    }
+    /**
+     * Enable maker pre-interaction
+     */
+    enablePreInteraction() {
+        this.value = this.value.setBit(MakerTraits.PRE_INTERACTION_CALL_FLAG, 1);
+        return this;
+    }
+    /**
+     * Disable maker pre-interaction
+     */
+    disablePreInteraction() {
+        this.value = this.value.setBit(MakerTraits.PRE_INTERACTION_CALL_FLAG, 0);
+        return this;
+    }
+    /**
+     * Returns true if maker has post-interaction and false otherwise
+     */
+    hasPostInteraction() {
+        return this.value.getBit(MakerTraits.POST_INTERACTION_CALL_FLAG) === 1;
+    }
+    /**
+     * Enable maker post-interaction
+     */
+    enablePostInteraction() {
+        this.value = this.value.setBit(MakerTraits.POST_INTERACTION_CALL_FLAG, 1);
+        return this;
+    }
+    /**
+     * Disable maker post-interaction
+     */
+    disablePostInteraction() {
+        this.value = this.value.setBit(MakerTraits.POST_INTERACTION_CALL_FLAG, 0);
+        return this;
+    }
+    /**
+     * Returns true if epoch manager enabled
+     *
+     * @see MakerTraits.enableEpochManagerCheck
+     */
+    isEpochManagerEnabled() {
+        return (this.value.getBit(MakerTraits.NEED_CHECK_EPOCH_MANAGER_FLAG) === 1);
+    }
+    /**
+     * Returns true if `permit2` enabled for maker funds transfer
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    isPermit2() {
+        return this.value.getBit(MakerTraits.USE_PERMIT2_FLAG) === 1;
+    }
+    /**
+     * Use `permit2` to transfer maker funds to contract
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    enablePermit2() {
+        this.value = this.value.setBit(MakerTraits.USE_PERMIT2_FLAG, 1);
+        return this;
+    }
+    /**
+     * Do not use `permit2` to transfer maker funds to contract
+     *
+     * @see https://github.com/Uniswap/permit2
+     */
+    disablePermit2() {
+        this.value = this.value.setBit(MakerTraits.USE_PERMIT2_FLAG, 0);
+        return this;
+    }
+    /**
+     * Is WRAPPED token will be unwrapped to NATIVE before sending to maker
+     */
+    isNativeUnwrapEnabled() {
+        return this.value.getBit(MakerTraits.UNWRAP_WETH_FLAG) === 1;
+    }
+    /**
+     * Unwrap WRAPPED token to NATIVE before sending it to maker
+     */
+    enableNativeUnwrap() {
+        this.value = this.value.setBit(MakerTraits.UNWRAP_WETH_FLAG, 1);
+        return this;
+    }
+    /**
+     * Do not unwrap WRAPPED token to NATIVE before sending it to maker
+     */
+    disableNativeUnwrap() {
+        this.value = this.value.setBit(MakerTraits.UNWRAP_WETH_FLAG, 0);
+        return this;
+    }
+    asBigInt() {
+        return this.value.value;
+    }
+    /**
+     * Returns true if bit invalidator mode is used to invalidate order (cancel/mark as filled)
+     *
+     * Bit invalidator is cheaper in terms of gas, but can be used only when partial fills OR multiple fills are disabled
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/3c9b8ab8bbc4c10ff8d615fc3d33f501993c292d/contracts/libraries/MakerTraitsLib.sol#L142
+     */
+    isBitInvalidatorMode() {
+        return !this.isPartialFillAllowed() || !this.isMultipleFillsAllowed();
+    }
+    enableEpochManagerCheck() {
+        assert(!this.isBitInvalidatorMode(), 'Epoch manager allowed only when partialFills and multipleFills enabled');
+        this.value = this.value.setBit(MakerTraits.NEED_CHECK_EPOCH_MANAGER_FLAG, 1);
+    }
+    /**
+     * Set series. Only when epoch manager enabled
+     * Series is a subgroup for epoch's, it can be useful when you want to cancel a group of orders at once
+     *
+     * @see MakerTraits.enableEpochManagerCheck
+     */
+    setSeries(series) {
+        this.value = this.value.setMask(MakerTraits.SERIES_MASK, series);
+    }
+}
+// Low 200 bits are used for allowed sender, expiration, nonceOrEpoch, and series
+MakerTraits.ALLOWED_SENDER_MASK = new BitMask(0n, 80n);
+MakerTraits.EXPIRATION_MASK = new BitMask(80n, 120n);
+MakerTraits.NONCE_OR_EPOCH_MASK = new BitMask(120n, 160n);
+MakerTraits.SERIES_MASK = new BitMask(160n, 200n);
+MakerTraits.NO_PARTIAL_FILLS_FLAG = 255n;
+MakerTraits.ALLOW_MULTIPLE_FILLS_FLAG = 254n;
+MakerTraits.PRE_INTERACTION_CALL_FLAG = 252n;
+MakerTraits.POST_INTERACTION_CALL_FLAG = 251n;
+MakerTraits.NEED_CHECK_EPOCH_MANAGER_FLAG = 250n;
+MakerTraits.HAS_EXTENSION_FLAG = 249n;
+MakerTraits.USE_PERMIT2_FLAG = 248n;
+MakerTraits.UNWRAP_WETH_FLAG = 247n;

package/dist/limit-order/maker-traits.spec.d.ts

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