@1inch/fusion-sdk 2.4.7-rc.1 → 2.4.7-rc.3

package/dist/esm/fusion-order/permit/permit-transfer-from.spec.js

@@ -0,0 +1,228 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { Address } from '@1inch/limit-order-sdk';
+import { verifyTypedData, Wallet } from 'ethers';
+import { PermitTransferFrom } from './permit-transfer-from.js';
+import { PERMIT2_DOMAIN_NAME, PERMIT_TRANSFER_FROM_TYPES } from './constants.js';
+import { getPermit2Address } from './utils.js';
+import { NetworkEnum } from '../../constants.js';
+describe('PermitTransferFrom', function() {
+    var token = new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2');
+    var spender = new Address('0x1111111254eeb25477b68fb85ed929f73a960582');
+    var maxSpendAmount = 1000000000000000000n;
+    var nonce = 42n;
+    var deadline = 1700000000n;
+    it('should return correct typed data for ethereum', function() {
+        var permit = new PermitTransferFrom(token, maxSpendAmount, spender, nonce, deadline);
+        var typedData = permit.getTypedData(NetworkEnum.ETHEREUM);
+        expect(typedData).toStrictEqual({
+            primaryType: 'PermitTransferFrom',
+            types: PERMIT_TRANSFER_FROM_TYPES,
+            domain: {
+                name: PERMIT2_DOMAIN_NAME,
+                chainId: NetworkEnum.ETHEREUM,
+                verifyingContract: getPermit2Address(NetworkEnum.ETHEREUM)
+            },
+            message: {
+                permitted: {
+                    token: token.toString(),
+                    amount: maxSpendAmount
+                },
+                spender: spender.toString(),
+                nonce: nonce,
+                deadline: deadline
+            }
+        });
+    });
+    it('should use zksync permit2 address for zksync chain', function() {
+        var permit = new PermitTransferFrom(token, maxSpendAmount, spender, nonce, deadline);
+        var typedData = permit.getTypedData(NetworkEnum.ZKSYNC);
+        expect(typedData.domain.verifyingContract).toBe(getPermit2Address(NetworkEnum.ZKSYNC));
+    });
+    it('should use custom permit2 address when provided', function() {
+        var customPermit2 = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+        var permit = new PermitTransferFrom(token, maxSpendAmount, spender, nonce, deadline);
+        var typedData = permit.getTypedData(NetworkEnum.ETHEREUM, customPermit2);
+        expect(typedData.domain.verifyingContract).toBe(customPermit2);
+    });
+    it('should throw for unsupported chain id without custom address', function() {
+        var permit = new PermitTransferFrom(token, maxSpendAmount, spender, nonce, deadline);
+        expect(function() {
+            return permit.getTypedData(999);
+        }).toThrow('unsupported chainId');
+    });
+    it('should produce signable typed data that recovers to the signer', /*#__PURE__*/ _async_to_generator(function() {
+        var wallet, permit, typedData, types, signature, recovered;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    wallet = Wallet.createRandom();
+                    permit = new PermitTransferFrom(token, maxSpendAmount, spender, nonce, deadline);
+                    typedData = permit.getTypedData(NetworkEnum.ETHEREUM);
+                    types = _object_spread({}, typedData.types);
+                    delete types['EIP712Domain'];
+                    return [
+                        4,
+                        wallet.signTypedData(typedData.domain, types, typedData.message)
+                    ];
+                case 1:
+                    signature = _state.sent();
+                    recovered = verifyTypedData(typedData.domain, types, typedData.message, signature);
+                    expect(recovered).toBe(wallet.address);
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+});

package/dist/esm/fusion-order/permit/transfer-from-suffix.js

@@ -0,0 +1,38 @@
+import { Address } from '@1inch/limit-order-sdk';
+import { AbiCoder } from 'ethers';
+import assert from 'assert';
+/**
+ * Permit2Proxy exposes `func_nZHTch(address,address,uint256,((address,uint256),uint256,uint256),bytes)`
+ * whose selector collides with `transferFrom(address,address,uint256)` (0x23b872dd).
+ * The LOP calls `_callTransferFromWithSuffix`, appending these extra params as raw suffix bytes.
+ */ var PERMIT2_TRANSFER_FROM_EXTRA_PARAMS_ABI = [
+    'tuple(tuple(address token, uint256 amount) permitted, uint256 nonce, uint256 deadline)',
+    'bytes'
+];
+var abiCoder = AbiCoder.defaultAbiCoder();
+export function encodeTransferFromSuffix(token, amount, nonce, deadline, signature) {
+    return abiCoder.encode(PERMIT2_TRANSFER_FROM_EXTRA_PARAMS_ABI, [
+        {
+            permitted: {
+                token: token.toString(),
+                amount: amount
+            },
+            nonce: nonce,
+            deadline: deadline
+        },
+        signature
+    ]);
+}
+export function decodeTransferFromSuffix(suffix) {
+    var decoded = abiCoder.decode(PERMIT2_TRANSFER_FROM_EXTRA_PARAMS_ABI, suffix);
+    var permit = decoded[0];
+    var sig = decoded[1];
+    assert(sig.length > 0, 'empty permit signature');
+    return {
+        token: new Address(permit.permitted.token),
+        amount: BigInt(permit.permitted.amount),
+        nonce: BigInt(permit.nonce),
+        deadline: BigInt(permit.deadline),
+        signature: sig
+    };
+}

package/dist/esm/fusion-order/permit/utils.js

@@ -0,0 +1,12 @@
+import { Address } from '@1inch/limit-order-sdk';
+import assert from 'assert';
+import { PERMIT2_ADDRESSES, PERMIT2_PROXY_ADDRESSES } from './constants.js';
+import { NetworkEnum } from '../../constants.js';
+export function getPermit2Address(chainId) {
+    assert(NetworkEnum[chainId], 'unsupported chainId');
+    return PERMIT2_ADDRESSES[chainId];
+}
+export function getPermit2ProxyAddress(chainId) {
+    assert(NetworkEnum[chainId], 'unsupported chainId');
+    return new Address(PERMIT2_PROXY_ADDRESSES[chainId]);
+}

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-export { Address, Extension, randBigInt, getLimitOrderContract, Interaction, TakerTraits, ExtensionBuilder, AmountMode, getLimitOrderV4Domain, LimitOrderContract, MakerTraits, ProxyFactory, NativeOrdersFactory, NativeOrdersImpl, Bps } from '@1inch/limit-order-sdk';
+export { Address, Extension, randBigInt, getLimitOrderContract, Interaction, TakerTraits, ExtensionBuilder, AmountMode, getLimitOrderV4Domain, LimitOrderContract, MakerTraits, ProxyFactory, NativeOrdersFactory, NativeOrdersImpl } from '@1inch/limit-order-sdk';
 export * from './fusion-order/index.js';
 export * from './amount-calculator//index.js';
 export * from './connector/index.js';

package/dist/esm/package.json

@@ -1 +1 @@
-{"name":"@1inch/fusion-sdk","version":"2.4.7-rc.1","type":"module"}
+{"name":"@1inch/fusion-sdk","version":"2.4.7-rc.3","type":"module"}

package/dist/esm/sdk/README.md

@@ -204,11 +204,12 @@ sdk.placeOrder({
     toTokenAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', // USDC
     amount: '50000000000000000', // 0.05 ETH
     walletAddress: makerAddress,
-    // integratorFee is an optional field
-    integratorFee: {
-        receiver: new Address('0x0000000000000000000000000000000000000000'), //  fee receiver address
-        value: new Bps(100n) // 1% as we use bps format, 1% is equal to 100bps
-    }
+    // fee is an optional field
+    fee: {
+        takingFeeBps: 100, // 1% as we use bps format, 1% is equal to 100bps
+        takingFeeReceiver: '0x0000000000000000000000000000000000000000' //  fee receiver address
+    },
+    source: 'platform-name'
 }).then(console.log)
 ```
 
@@ -223,15 +224,6 @@ type PaginationParams = {
 }
 ```
 
-### IntegratorFeeRequest
-
-```typescript
-type IntegratorFeeRequest = {
-    receiver: Address // fee receiver address
-    value: Bps // 100 == 1%
-}
-```
-
 ### QuoteParams
 
 ```typescript
@@ -239,9 +231,8 @@ type QuoteParams = {
     fromTokenAddress: string
     toTokenAddress: string
     amount: string
-    walletAddress?: string
     permit?: string // a permit (EIP-2612) call data, user approval sign
-    integratorFee?: IntegratorFeeRequest
+    takingFeeBps?: number // 100 == 1%
 }
 ```
 
@@ -262,7 +253,12 @@ type OrderParams = {
     permit?: string // a permit (EIP-2612) call data, user approval sign
     receiver?: string // address
     preset?: PresetEnum
-    nonce?: bigint // allows to batch cancel orders
-    integratorFee?: IntegratorFeeRequest
+    nonce?: OrderNonce | string | number // allows to batch cancel orders. by default: not used
+    fee?: TakingFeeInfo
+}
+
+export type TakingFeeInfo = {
+    takingFeeBps: number // 100 == 1%
+    takingFeeReceiver: string
 }
 ```

package/dist/types/src/api/quoter/quote/quote.d.ts

@@ -1,5 +1,5 @@
 import { Address, ProxyFactory } from '@1inch/limit-order-sdk';
-import { FusionOrderParamsData, IntegratorFeeResponse, ResolverFeePreset } from './types.js';
+import { FusionOrderParamsData, IntegratorFeeParams, ResolverFeePreset } from './types.js';
 import { Cost, PresetEnum, QuoterResponse } from '../types.js';
 import { Preset } from '../preset.js';
 import { FusionOrder } from '../../../fusion-order/index.js';
@@ -25,11 +25,10 @@ export declare class Quote {
     readonly slippage: number;
     readonly resolverFeePreset: ResolverFeePreset;
     readonly surplusFee?: number;
-    readonly integratorFeeParams?: IntegratorFeeResponse;
+    readonly integratorFeeParams?: IntegratorFeeParams;
     constructor(params: QuoterRequest, response: QuoterResponse);
     createFusionOrder(paramsData: Omit<FusionOrderParamsData, 'permit' | 'isPermit2'>): FusionOrder;
     getPreset(type?: PresetEnum): Preset;
     private getWhitelist;
     private _createOrder;
-    private parseIntegratorFee;
 }

package/dist/types/src/api/quoter/quote/types.d.ts

@@ -13,16 +13,11 @@ export type FusionOrderParamsData = {
     delayAuctionStartTimeBy?: bigint;
     orderExpirationDelay?: bigint;
 };
-export type IntegratorFeeRequest = {
-    receiver: Address;
-    value: Bps;
-};
-export type IntegratorFeeResponse = {
+export type IntegratorFeeParams = {
     receiver: Address;
     value: Bps;
     share: Bps;
 };
-export type IntegratorFeeParams = IntegratorFeeResponse;
 export type ResolverFeePreset = {
     receiver: Address;
     bps: Bps;

package/dist/types/src/api/quoter/quoter.request.d.ts

@@ -1,6 +1,6 @@
 import { Address } from '@1inch/limit-order-sdk';
 import { QuoterRequestParams, QuoterRequestParamsRaw } from './types.js';
-import { IntegratorFeeRequest } from './quote/index.js';
+import { IntegratorFeeParams } from './quote/index.js';
 export declare class QuoterRequest {
     readonly fromTokenAddress: Address;
     readonly toTokenAddress: Address;
@@ -8,8 +8,8 @@ export declare class QuoterRequest {
     readonly walletAddress: Address;
     readonly enableEstimate: boolean;
     readonly permit: string | undefined;
-    readonly integratorFee?: IntegratorFeeRequest;
-    readonly source?: string;
+    readonly integratorFee?: IntegratorFeeParams;
+    readonly source: string;
     readonly isPermit2: boolean;
     readonly slippage?: number;
     constructor(params: QuoterRequestParams);

package/dist/types/src/api/quoter/types.d.ts

@@ -1,4 +1,4 @@
-import { IntegratorFeeRequest } from './quote/index.js';
+import { IntegratorFeeParams } from './quote/index.js';
 import { NetworkEnum } from '../../constants.js';
 export type QuoterRequestParams = {
     fromTokenAddress: string;
@@ -7,7 +7,7 @@ export type QuoterRequestParams = {
     walletAddress: string;
     enableEstimate?: boolean;
     permit?: string;
-    integratorFee?: IntegratorFeeRequest;
+    integratorFee?: IntegratorFeeParams;
     source?: string;
     isPermit2?: boolean;
     slippage?: number;

package/dist/types/src/constants.d.ts

@@ -15,6 +15,7 @@ export declare enum NetworkEnum {
     UNICHAIN = 130
 }
 export declare const ONE_INCH_LIMIT_ORDER_V4 = "0x111111125421ca6dc452d289314280a0f8842a65";
+export declare const ONE_INCH_LIMIT_ORDER_V4_ADDRESSES: Record<NetworkEnum, string>;
 export declare const UINT_160_MAX: bigint;
 export declare const UINT_16_MAX: bigint;
 export declare const UINT_80_MAX: bigint;

package/dist/types/src/fusion-order/fusion-order.d.ts

@@ -4,6 +4,7 @@ import { AuctionDetails } from './auction-details/index.js';
 import { Whitelist } from './whitelist/whitelist.js';
 import { SurplusParams } from './surplus-params.js';
 import type { Details, Extra } from './types.js';
+import { PermitTransferFrom } from './permit/permit-transfer-from.js';
 import { AuctionCalculator } from '../amount-calculator/auction-calculator/index.js';
 import { NetworkEnum } from '../constants.js';
 import { AmountCalculator } from '../amount-calculator/amount-calculator.js';
@@ -33,6 +34,8 @@ export declare class FusionOrder {
     static isNativeOrder(chainId: number, ethOrderFactory: ProxyFactory, order: LimitOrderV4Struct, signature: string): boolean;
     static fromNative(chainId: NetworkEnum, ethOrdersFactory: ProxyFactory, settlementExtension: Address, orderInfo: Omit<OrderInfoData, 'makerAsset'>, details: Details, extra?: Extra): FusionOrder;
     static fromDataAndExtension(order: LimitOrderV4Struct, extension: Extension): FusionOrder;
+    isTransferPermit(): boolean;
+    withTransferPermit(permit: PermitTransferFrom, signature: string): this;
     build(): LimitOrderV4Struct;
     getOrderHash(chainId: number): string;
     getTypedData(chainId: number): EIP712TypedData;
@@ -51,4 +54,7 @@ export declare class FusionOrder {
     getAmountCalculator(): AmountCalculator;
     isNative(chainId: number, ethOrderFactory: ProxyFactory, signature: string): boolean;
     nativeSignature(maker: Address): string;
+    createTransferPermit(chainIdOrPermit2Proxy: number | Address, permit2Proxy?: Address): PermitTransferFrom;
+    private restoreMakerAssetSuffix;
+    private decodeTransferPermitSuffix;
 }

package/dist/types/src/fusion-order/index.d.ts

@@ -6,3 +6,4 @@ export * from './fees/index.js';
 export { CHAIN_TO_WRAPPER } from './constants.js';
 export * from './surplus-params.js';
 export * from './cancellation-auction.js';
+export * from './permit/index.js';

package/dist/types/src/fusion-order/permit/constants.d.ts

@@ -0,0 +1,7 @@
+import { EIP712Types } from '@1inch/limit-order-sdk';
+import { NetworkEnum } from '../../constants.js';
+export declare const PERMIT2_ADDRESSES: Record<NetworkEnum, string>;
+export declare const PERMIT2_PROXY_ADDRESSES: Record<NetworkEnum, string>;
+export declare const PERMIT2_DOMAIN_NAME = "Permit2";
+export declare const TOKEN_PERMISSIONS: EIP712Types;
+export declare const PERMIT_TRANSFER_FROM_TYPES: EIP712Types;

package/dist/types/src/fusion-order/permit/index.d.ts

@@ -0,0 +1,3 @@
+export * from './permit-transfer-from.js';
+export * from './transfer-from-suffix.js';
+export { getPermit2Address, getPermit2ProxyAddress } from './utils.js';

package/dist/types/src/fusion-order/permit/permit-transfer-from.d.ts

@@ -0,0 +1,11 @@
+import { Address, EIP712TypedData } from '@1inch/limit-order-sdk';
+export declare class PermitTransferFrom {
+    readonly token: Address;
+    readonly maxSpendAmount: bigint;
+    readonly spender: Address;
+    readonly nonce: bigint;
+    readonly deadline: bigint;
+    constructor(token: Address, maxSpendAmount: bigint, spender: Address, nonce: bigint, deadline: bigint);
+    getTypedData(chainId: number, permit2Address?: string): EIP712TypedData;
+    getTransferFromSuffix(signature: string): string;
+}

package/dist/types/src/fusion-order/permit/transfer-from-suffix.d.ts

@@ -0,0 +1,10 @@
+import { Address } from '@1inch/limit-order-sdk';
+export type DecodedTransferPermitSuffix = {
+    token: Address;
+    amount: bigint;
+    nonce: bigint;
+    deadline: bigint;
+    signature: string;
+};
+export declare function encodeTransferFromSuffix(token: Address, amount: bigint, nonce: bigint, deadline: bigint, signature: string): string;
+export declare function decodeTransferFromSuffix(suffix: string): DecodedTransferPermitSuffix;

package/dist/types/src/fusion-order/permit/utils.d.ts

@@ -0,0 +1,3 @@
+import { Address } from '@1inch/limit-order-sdk';
+export declare function getPermit2Address(chainId: number): string;
+export declare function getPermit2ProxyAddress(chainId: number): Address;

package/dist/types/src/index.d.ts

@@ -1,4 +1,4 @@
-export { Address, type LimitOrderV4Struct, Extension, randBigInt, getLimitOrderContract, Interaction, TakerTraits, ExtensionBuilder, AmountMode, getLimitOrderV4Domain, LimitOrderContract, type OrderInfoData, type EIP712TypedData, MakerTraits, ProxyFactory, NativeOrdersFactory, NativeOrdersImpl, Bps } from '@1inch/limit-order-sdk';
+export { Address, type LimitOrderV4Struct, Extension, randBigInt, getLimitOrderContract, Interaction, TakerTraits, ExtensionBuilder, AmountMode, getLimitOrderV4Domain, LimitOrderContract, type OrderInfoData, type EIP712TypedData, MakerTraits, ProxyFactory, NativeOrdersFactory, NativeOrdersImpl } from '@1inch/limit-order-sdk';
 export * from './fusion-order/index.js';
 export * from './amount-calculator//index.js';
 export * from './connector/index.js';
@@ -10,4 +10,4 @@ export * from './utils/time.js';
 export * from './validations.js';
 export * from './ws-api/index.js';
 export * from './errors.js';
-export { QuoterRequest, type QuoterResponse, RelayerRequest, QuoterCustomPresetRequest, PresetEnum, Preset, Quote, type OrderStatusResponse, OrderStatus, type IntegratorFeeRequest, type IntegratorFeeResponse } from './api/index.js';
+export { QuoterRequest, type QuoterResponse, RelayerRequest, QuoterCustomPresetRequest, PresetEnum, Preset, Quote, type OrderStatusResponse, OrderStatus } from './api/index.js';

package/dist/types/src/sdk/types.d.ts

@@ -1,7 +1,7 @@
 import { Address, LimitOrderV4Struct } from '@1inch/limit-order-sdk';
 import { BlockchainProviderConnector, HttpProviderConnector } from '../connector/index.js';
 import { NetworkEnum } from '../constants.js';
-import { CustomPreset, IntegratorFeeRequest, PresetEnum } from '../api/index.js';
+import { CustomPreset, IntegratorFeeParams, PresetEnum } from '../api/index.js';
 import { FusionOrder } from '../fusion-order/index.js';
 export type FusionSDKConfigParams = {
     url: string;
@@ -17,7 +17,7 @@ export type QuoteParams = {
     walletAddress?: string;
     enableEstimate?: boolean;
     permit?: string;
-    integratorFee?: IntegratorFeeRequest;
+    integratorFee?: IntegratorFeeParams;
     source?: string;
     isPermit2?: boolean;
     slippage?: number;
@@ -40,7 +40,7 @@ export type OrderParams = {
     orderExpirationDelay?: bigint;
     allowPartialFills?: boolean;
     allowMultipleFills?: boolean;
-    integratorFee?: IntegratorFeeRequest;
+    integratorFee?: IntegratorFeeParams;
     slippage?: number;
 };
 export type OrderInfo = {