@stryke-xyz/premarket-sdk 1.0.0

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

@@ -0,0 +1,26 @@
+export class WhitelistHalfAddress {
+    constructor(
+    /**
+     * Last 10 bytes of addresses
+     */
+    addresses) {
+        this.addresses = addresses;
+    }
+    get length() {
+        return this.addresses.length;
+    }
+    static new(addresses) {
+        return new WhitelistHalfAddress(addresses?.map((w) => w.lastHalf()) || []);
+    }
+    isWhitelisted(address) {
+        const half = address.lastHalf();
+        return this.addresses.some((w) => w === half);
+    }
+    encodeTo(builder) {
+        builder.addUint8(BigInt(this.addresses.length));
+        for (const halfAddress of this.addresses) {
+            builder.addBytes(halfAddress);
+        }
+        return builder;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './extension.js';
+export * from './extension-builder.js';
+export * as FeeTakerExt from './fee-taker/index.js';

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

@@ -0,0 +1,3 @@
+export * from './extension.js';
+export * from './extension-builder.js';
+export * as FeeTakerExt from './fee-taker/index.js';

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

@@ -0,0 +1,10 @@
+export * from './eip712/index.js';
+export * from './limit-order.js';
+export * from './limit-order-with-fee.js';
+export * from './maker-traits.js';
+export * from './taker-traits.js';
+export * from './extensions/index.js';
+export * from './interaction.js';
+export * from './types.js';
+export * from './amounts.js';
+export * from './verification.js';

package/dist/limit-order/index.js

@@ -0,0 +1,10 @@
+export * from './eip712/index.js';
+export * from './limit-order.js';
+export * from './limit-order-with-fee.js';
+export * from './maker-traits.js';
+export * from './taker-traits.js';
+export * from './extensions/index.js';
+export * from './interaction.js';
+export * from './types.js';
+export * from './amounts.js';
+export * from './verification.js';

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

@@ -0,0 +1,16 @@
+import { Address } from '../address.js';
+export declare class Interaction {
+    readonly target: Address;
+    readonly data: string;
+    constructor(target: Address, data: string);
+    /**
+     * Create `Interaction` from bytes
+     *
+     * @param bytes Hex string with 0x. First 20 bytes are target, then data
+     */
+    static decode(bytes: string): Interaction;
+    /**
+     * Hex string with 0x. First 20 bytes are target, then data
+     */
+    encode(): string;
+}

package/dist/limit-order/interaction.js

@@ -0,0 +1,25 @@
+import { BytesIter, isHexBytes, trim0x } from '@1inch/byte-utils';
+import assert from 'assert';
+import { Address } from '../address.js';
+export class Interaction {
+    constructor(target, data) {
+        this.target = target;
+        this.data = data;
+        assert(isHexBytes(data), 'Interaction data must be valid hex bytes');
+    }
+    /**
+     * Create `Interaction` from bytes
+     *
+     * @param bytes Hex string with 0x. First 20 bytes are target, then data
+     */
+    static decode(bytes) {
+        const iter = BytesIter.HexString(bytes);
+        return new Interaction(new Address(iter.nextUint160()), iter.rest());
+    }
+    /**
+     * Hex string with 0x. First 20 bytes are target, then data
+     */
+    encode() {
+        return this.target.toString() + trim0x(this.data);
+    }
+}

package/dist/limit-order/interaction.spec.d.ts

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

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

@@ -0,0 +1,8 @@
+import { Interaction } from './interaction.js';
+import { Address } from '../address.js';
+describe('Interaction', () => {
+    it('should encode/decode', () => {
+        const interaction = new Interaction(Address.fromBigInt(1337n), '0xdeadbeef');
+        expect(Interaction.decode(interaction.encode())).toStrictEqual(interaction);
+    });
+});

package/dist/limit-order/limit-order-with-fee.d.ts

@@ -0,0 +1,59 @@
+import { FeeTakerExtension } from './extensions/fee-taker/fee-taker.extension.js';
+import { LimitOrder } from './limit-order.js';
+import { LimitOrderV4Struct, OrderInfoData } from './types.js';
+import { MakerTraits } from './maker-traits.js';
+import { Extension } from './extensions/extension.js';
+import { Address } from '../address.js';
+export declare class LimitOrderWithFee extends LimitOrder {
+    readonly feeExtension: FeeTakerExtension;
+    constructor(
+    /**
+     * Use `FeeTakerExtension.customReceiver` to set custom receiver
+     */
+    orderInfo: Omit<OrderInfoData, 'receiver'>, makerTraits: MakerTraits | undefined, feeExtension: FeeTakerExtension);
+    /**
+     * Set random nonce to `makerTraits` and creates `LimitOrderWithFee`
+     */
+    static withRandomNonce(
+    /**
+     * Use `FeeTakerExtension.recipients.tokensRecipient` to set custom receiver
+     */
+    orderInfo: Omit<OrderInfoData, 'receiver'>, feeExtension: FeeTakerExtension, makerTraits?: MakerTraits): LimitOrderWithFee;
+    static fromDataAndExtension(data: LimitOrderV4Struct, extension: Extension): LimitOrderWithFee;
+    /**
+     * Calculates the `takingAmount` required from the taker in exchange for the `makingAmount`
+     *
+     * @param taker
+     * @param makingAmount amount to be filled
+     */
+    getTakingAmount(taker: Address, makingAmount?: bigint): bigint;
+    /**
+     * Calculates the `makingAmount` that the taker receives in exchange for the `takingAmount`
+     *
+     * @param taker
+     * @param takingAmount amount to be filled
+     */
+    getMakingAmount(taker: Address, takingAmount?: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param makingAmount amount wanted to fill
+     */
+    getResolverFee(taker: Address, makingAmount?: bigint): bigint;
+    /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param makingAmount amount wanted to fill
+     */
+    getIntegratorFee(taker: Address, makingAmount?: 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 makingAmount amount wanted to fill
+     */
+    getProtocolFee(taker: Address, makingAmount?: bigint): bigint;
+}

package/dist/limit-order/limit-order-with-fee.js

@@ -0,0 +1,94 @@
+import { UINT_40_MAX } from '@1inch/byte-utils';
+import assert from 'assert';
+import { FeeTakerExtension } from './extensions/fee-taker/fee-taker.extension.js';
+import { LimitOrder } from './limit-order.js';
+import { MakerTraits } from './maker-traits.js';
+import { calcMakingAmount, calcTakingAmount } from './amounts.js';
+import { Address } from '../address.js';
+import { randBigInt } from '../utils/rand-bigint.js';
+export class LimitOrderWithFee extends LimitOrder {
+    constructor(
+    /**
+     * Use `FeeTakerExtension.customReceiver` to set custom receiver
+     */
+    orderInfo, makerTraits = MakerTraits.default(), feeExtension) {
+        makerTraits.enablePostInteraction(); // to execute extension
+        super({ ...orderInfo, receiver: feeExtension.address }, makerTraits, feeExtension.build());
+        this.feeExtension = feeExtension;
+    }
+    /**
+     * Set random nonce to `makerTraits` and creates `LimitOrderWithFee`
+     */
+    static withRandomNonce(
+    /**
+     * Use `FeeTakerExtension.recipients.tokensRecipient` to set custom receiver
+     */
+    orderInfo, feeExtension, makerTraits = MakerTraits.default()) {
+        makerTraits.withNonce(randBigInt(UINT_40_MAX));
+        return new LimitOrderWithFee(orderInfo, makerTraits, feeExtension);
+    }
+    static fromDataAndExtension(data, extension) {
+        const makerTraits = new MakerTraits(BigInt(data.makerTraits));
+        const feeExt = FeeTakerExtension.fromExtension(extension);
+        assert(feeExt.address.equal(new Address(data.receiver)), `invalid order: receiver must be FeeTaker extension address`);
+        return new LimitOrderWithFee({
+            salt: BigInt(data.salt),
+            maker: new Address(data.maker),
+            makerAsset: new Address(data.makerAsset),
+            takerAsset: new Address(data.takerAsset),
+            makingAmount: BigInt(data.makingAmount),
+            takingAmount: BigInt(data.takingAmount)
+        }, makerTraits, feeExt);
+    }
+    /**
+     * Calculates the `takingAmount` required from the taker in exchange for the `makingAmount`
+     *
+     * @param taker
+     * @param makingAmount amount to be filled
+     */
+    getTakingAmount(taker, makingAmount = this.makingAmount) {
+        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+        return this.feeExtension.getTakingAmount(taker, takingAmount);
+    }
+    /**
+     * Calculates the `makingAmount` that the taker receives in exchange for the `takingAmount`
+     *
+     * @param taker
+     * @param takingAmount amount to be filled
+     */
+    getMakingAmount(taker, takingAmount = this.takingAmount) {
+        const makingAmount = calcMakingAmount(takingAmount, this.makingAmount, this.takingAmount);
+        return this.feeExtension.getMakingAmount(taker, makingAmount);
+    }
+    /**
+     * Fee in `takerAsset` which resolver pays to resolver fee receiver
+     *
+     * @param taker who will fill order
+     * @param makingAmount amount wanted to fill
+     */
+    getResolverFee(taker, makingAmount = this.makingAmount) {
+        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+        return this.feeExtension.getResolverFee(taker, takingAmount);
+    }
+    /**
+     * Fee in `takerAsset` which integrator gets to integrator wallet
+     *
+     * @param taker who will fill order
+     * @param makingAmount amount wanted to fill
+     */
+    getIntegratorFee(taker, makingAmount = this.makingAmount) {
+        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+        return this.feeExtension.getIntegratorFee(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 makingAmount amount wanted to fill
+     */
+    getProtocolFee(taker, makingAmount = this.makingAmount) {
+        const takingAmount = calcTakingAmount(makingAmount, this.makingAmount, this.takingAmount);
+        return this.feeExtension.getProtocolFee(taker, takingAmount);
+    }
+}

package/dist/limit-order/limit-order-with-fee.spec.d.ts

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

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

@@ -0,0 +1,31 @@
+import { LimitOrderWithFee } from './limit-order-with-fee.js';
+import { FeeTakerExtension } from './extensions/fee-taker/fee-taker.extension.js';
+import { Fees } from './extensions/fee-taker/fees.js';
+import { ResolverFee } from './extensions/fee-taker/resolver-fee.js';
+import { IntegratorFee } from './extensions/fee-taker/integrator-fee.js';
+import { Interaction } from './interaction.js';
+import { MakerTraits } from './maker-traits.js';
+import { Address } from '../address.js';
+import { Bps } from '../bps.js';
+describe('LimitOrderWithFee', () => {
+    it('should create fromDataAndExtension', () => {
+        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)), 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
+        });
+        const order = new LimitOrderWithFee({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa')
+        }, MakerTraits.default(), extension);
+        expect(LimitOrderWithFee.fromDataAndExtension(order.build(), order.extension)).toEqual(order);
+    });
+});

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

@@ -0,0 +1,63 @@
+import { EIP712TypedData } from './eip712/index.js';
+import { LimitOrderV4Struct, OrderInfoData } from './types.js';
+import { MakerTraits } from './maker-traits.js';
+import { Extension } from './extensions/extension.js';
+import { Address } from '../address.js';
+import { ProxyFactory } from '../limit-order-contract/index.js';
+export declare class LimitOrder {
+    readonly extension: Extension;
+    static readonly CHAIN_TO_WRAPPER: Record<number, Address>;
+    private static readonly Web3Type;
+    readonly maker: Address;
+    receiver: Address;
+    readonly makerAsset: Address;
+    readonly takerAsset: Address;
+    readonly makingAmount: bigint;
+    readonly takingAmount: bigint;
+    readonly makerTraits: MakerTraits;
+    private _salt;
+    constructor(orderInfo: OrderInfoData, makerTraits?: MakerTraits, extension?: Extension, config?: {
+        optimizeReceiverAddress: boolean;
+    });
+    get salt(): bigint;
+    /**
+     * Build correct salt for order
+     *
+     * If order has extension - it is crucial to build correct salt
+     * otherwise order won't be ever filled
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/7bc5129ae19832338169ca21e4cf6331e8ff44f6/contracts/OrderLib.sol#L153
+     *
+     */
+    static buildSalt(extension: Extension, baseSalt?: bigint): bigint;
+    static verifySalt(salt: bigint, extension: Extension): bigint;
+    static fromNative(chainId: number, nativeOrderFactory: ProxyFactory, orderInfo: Omit<OrderInfoData, 'makerAsset'>, makerTraits: MakerTraits, extension: Extension): LimitOrder;
+    static isNativeOrder(chainId: number, nativeOrderFactory: ProxyFactory, order: LimitOrderV4Struct, signature: string): boolean;
+    static fromCalldata(bytes: string): LimitOrder;
+    static fromDataAndExtension(data: LimitOrderV4Struct, extension: Extension): LimitOrder;
+    isNative(chainId: number, nativeOrderFactory: ProxyFactory, signature: string): boolean;
+    /**
+     * Returns signature for submitting native order on-chain
+     * Only valid if order is native
+     *
+     * @see FusionOrder.isNative
+     * @see FusionOrder.fromNative
+     */
+    nativeSignature(maker: Address): string;
+    /**
+     * Injects source info to order `salt` [224, 255] bits
+     * check `getTrackCodeForSource` implementation for exact injected data
+     *
+     * @param source order source identifier
+     * @see getTrackCodeForSource
+     */
+    setSource(source: string): this;
+    toCalldata(): string;
+    build(): LimitOrderV4Struct;
+    getTypedData(chainId: number): EIP712TypedData;
+    getOrderHash(chainId: number): string;
+    /**
+     * Returns true if only a specific address can fill order
+     */
+    isPrivate(): boolean;
+}

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

@@ -0,0 +1,211 @@
+import { AbiCoder } from 'ethers';
+import { isHexString, UINT_160_MAX, UINT_256_MAX } from '@1inch/byte-utils';
+import assert from 'assert';
+import { buildOrderTypedData, getLimitOrderV4Domain, getOrderHash } from './eip712/index.js';
+import { MakerTraits } from './maker-traits.js';
+import { Extension } from './extensions/extension.js';
+import { injectTrackCode } from './source-track.js';
+import { Address } from '../address.js';
+import { randBigInt } from '../utils/rand-bigint.js';
+export class LimitOrder {
+    constructor(orderInfo, makerTraits = new MakerTraits(0n), extension = Extension.default(), config = {
+        /**
+         * When enabled, orders where maker == receiver will have ZERO_ADDRESS set
+         * Used to save calldata costs
+         */
+        optimizeReceiverAddress: true
+    }) {
+        this.extension = extension;
+        assert(!orderInfo.takerAsset.isNative(), `${orderInfo.takerAsset} can not be 'takerAsset'. Use wrapper address as 'takerAsset' and 'makerTraits.enableNativeUnwrap' to swap to NATIVE currency`);
+        assert(!orderInfo.makerAsset.isNative(), 'Maker asset can not be NATIVE, use wrapper');
+        this.makerAsset = orderInfo.makerAsset;
+        this.takerAsset = orderInfo.takerAsset;
+        this.makingAmount = orderInfo.makingAmount;
+        this.takingAmount = orderInfo.takingAmount;
+        this._salt = LimitOrder.verifySalt(orderInfo.salt || LimitOrder.buildSalt(extension), extension);
+        this.maker = orderInfo.maker;
+        if (config.optimizeReceiverAddress) {
+            this.receiver = orderInfo.receiver?.equal(orderInfo.maker)
+                ? Address.ZERO_ADDRESS
+                : orderInfo.receiver || Address.ZERO_ADDRESS;
+        }
+        else {
+            this.receiver = orderInfo.receiver || orderInfo.maker;
+        }
+        this.makerTraits = makerTraits;
+        assert(this.makingAmount <= UINT_256_MAX, 'makingAmount too big');
+        assert(this.takingAmount <= UINT_256_MAX, 'takingAmount too big');
+        if (!extension.isEmpty()) {
+            this.makerTraits.withExtension();
+        }
+    }
+    get salt() {
+        return this._salt;
+    }
+    /**
+     * Build correct salt for order
+     *
+     * If order has extension - it is crucial to build correct salt
+     * otherwise order won't be ever filled
+     *
+     * @see https://github.com/1inch/limit-order-protocol/blob/7bc5129ae19832338169ca21e4cf6331e8ff44f6/contracts/OrderLib.sol#L153
+     *
+     */
+    static buildSalt(extension, baseSalt = randBigInt((1n << 96n) - 1n)) {
+        if (extension.isEmpty()) {
+            return baseSalt;
+        }
+        return (baseSalt << 160n) | (extension.keccak256() & UINT_160_MAX);
+    }
+    static verifySalt(salt, extension) {
+        assert(salt <= UINT_256_MAX, 'salt too big');
+        if (extension.isEmpty()) {
+            return salt;
+        }
+        const hash = salt & UINT_160_MAX;
+        const expectedHash = extension.keccak256() & UINT_160_MAX;
+        assert(hash === expectedHash, 'invalid salt: lowest 160 bits should be extension hash');
+        return salt;
+    }
+    static fromNative(chainId, nativeOrderFactory, orderInfo, makerTraits, extension) {
+        const _orderInfo = {
+            ...orderInfo,
+            makerAsset: LimitOrder.CHAIN_TO_WRAPPER[chainId],
+            receiver: orderInfo.receiver && !orderInfo.receiver.isZero()
+                ? orderInfo.receiver
+                : orderInfo.maker
+        };
+        // create temp order to calc order hash
+        const _order = new LimitOrder(_orderInfo, makerTraits, extension, {
+            optimizeReceiverAddress: false
+        });
+        const finalOrderInfo = {
+            ..._orderInfo,
+            salt: _order.salt,
+            maker: nativeOrderFactory.getProxyAddress(_order.getOrderHash(chainId))
+        };
+        return new LimitOrder(finalOrderInfo, makerTraits, extension, {
+            optimizeReceiverAddress: false
+        });
+    }
+    static isNativeOrder(chainId, nativeOrderFactory, order, signature) {
+        try {
+            const orderWithRealMaker = LimitOrder.fromCalldata(signature);
+            const expectedAddress = nativeOrderFactory.getProxyAddress(orderWithRealMaker.getOrderHash(chainId));
+            return expectedAddress.equal(new Address(order.maker));
+        }
+        catch {
+            return false;
+        }
+    }
+    static fromCalldata(bytes) {
+        assert(isHexString(bytes), 'Bytes should be valid hex string with 0x prefix');
+        const info = AbiCoder.defaultAbiCoder().decode([LimitOrder.Web3Type], bytes);
+        const order = info[0];
+        return new LimitOrder({
+            salt: order.salt ? BigInt(order.salt) : undefined,
+            maker: new Address(order.maker),
+            receiver: new Address(order.receiver),
+            takingAmount: BigInt(order.takingAmount),
+            makingAmount: BigInt(order.makingAmount),
+            takerAsset: new Address(order.takerAsset),
+            makerAsset: new Address(order.makerAsset)
+        }, new MakerTraits(BigInt(order.makerTraits)), undefined, { optimizeReceiverAddress: false });
+    }
+    static fromDataAndExtension(data, extension) {
+        return new LimitOrder({
+            salt: BigInt(data.salt),
+            maker: new Address(data.maker),
+            receiver: new Address(data.receiver),
+            takingAmount: BigInt(data.takingAmount),
+            makingAmount: BigInt(data.makingAmount),
+            takerAsset: new Address(data.takerAsset),
+            makerAsset: new Address(data.makerAsset)
+        }, new MakerTraits(BigInt(data.makerTraits)), extension, { optimizeReceiverAddress: false });
+    }
+    isNative(chainId, nativeOrderFactory, signature) {
+        return LimitOrder.isNativeOrder(chainId, nativeOrderFactory, this.build(), signature);
+    }
+    /**
+     * Returns signature for submitting native order on-chain
+     * Only valid if order is native
+     *
+     * @see FusionOrder.isNative
+     * @see FusionOrder.fromNative
+     */
+    nativeSignature(maker) {
+        return new LimitOrder({
+            maker,
+            makerAsset: this.makerAsset,
+            makingAmount: this.makingAmount,
+            takingAmount: this.takingAmount,
+            takerAsset: this.takerAsset,
+            receiver: this.receiver,
+            salt: this.salt
+        }, this.makerTraits, undefined, { optimizeReceiverAddress: false }).toCalldata();
+    }
+    /**
+     * Injects source info to order `salt` [224, 255] bits
+     * check `getTrackCodeForSource` implementation for exact injected data
+     *
+     * @param source order source identifier
+     * @see getTrackCodeForSource
+     */
+    setSource(source) {
+        this._salt = injectTrackCode(this.salt, source);
+        return this;
+    }
+    toCalldata() {
+        return AbiCoder.defaultAbiCoder().encode([LimitOrder.Web3Type], [this.build()]);
+    }
+    build() {
+        return {
+            maker: this.maker.toString(),
+            makerAsset: this.makerAsset.toString(),
+            takerAsset: this.takerAsset.toString(),
+            makerTraits: (this.makerTraits?.asBigInt() || 0n).toString(),
+            salt: this.salt.toString(),
+            makingAmount: this.makingAmount.toString(),
+            takingAmount: this.takingAmount.toString(),
+            receiver: this.receiver.toString()
+        };
+    }
+    getTypedData(chainId) {
+        const domain = getLimitOrderV4Domain(chainId);
+        return buildOrderTypedData(domain.chainId, domain.verifyingContract, domain.name, domain.version, this.build());
+    }
+    getOrderHash(chainId) {
+        return getOrderHash(this.getTypedData(chainId));
+    }
+    /**
+     * Returns true if only a specific address can fill order
+     */
+    isPrivate() {
+        return this.makerTraits.isPrivate();
+    }
+}
+LimitOrder.CHAIN_TO_WRAPPER = {
+    [1]: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+    [56]: new Address('0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c'),
+    [137]: new Address('0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270'),
+    [42161]: new Address('0x82af49447d8a07e3bd95bd0d56f35241523fbab1'),
+    [43114]: new Address('0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7'),
+    [100]: new Address('0xe91d153e0b41518a2ce8dd3d7944fa863463a97d'),
+    [8453]: new Address('0x4200000000000000000000000000000000000006'),
+    [10]: new Address('0x4200000000000000000000000000000000000006'),
+    [250]: new Address('0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83'),
+    [324]: new Address('0x5aea5775959fbc2557cc8789bc1bf90a239d9a91'),
+    [59144]: new Address('0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f'),
+    [130]: new Address('0x4200000000000000000000000000000000000006'),
+    [146]: new Address('0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38')
+};
+LimitOrder.Web3Type = `tuple(${[
+    'uint256 salt',
+    'address maker',
+    'address receiver',
+    'address makerAsset',
+    'address takerAsset',
+    'uint256 makingAmount',
+    'uint256 takingAmount',
+    'uint256 makerTraits'
+]})`;

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

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