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

package/dist/esm/api/quoter/quoter.request.spec.js

@@ -9,6 +9,7 @@ describe(__filename, function() {
                 amount: '1000000000000000000000',
                 walletAddress: '0x00000000219ab540356cbb839cbe05303d7705fa',
                 integratorFee: {
+                    share: Bps.fromPercent(50),
                     receiver: Address.fromBigInt(10n),
                     value: new Bps(1n)
                 }
@@ -21,6 +22,7 @@ describe(__filename, function() {
                 amount: '1000000000000000000000',
                 walletAddress: '0x00000000219ab540356cbb839cbe05303d7705fa',
                 integratorFee: {
+                    share: Bps.fromPercent(50),
                     receiver: Address.fromBigInt(10n),
                     value: new Bps(1n)
                 }
@@ -35,6 +37,7 @@ describe(__filename, function() {
                 amount: '1000000000000000000000',
                 walletAddress: '0x00000000219ab540356cbb839cbe05303d7705fa',
                 integratorFee: {
+                    share: Bps.fromPercent(50),
                     receiver: Address.fromBigInt(10n),
                     value: new Bps(1n)
                 }
@@ -49,6 +52,7 @@ describe(__filename, function() {
                 amount: '1000000000000000000000',
                 walletAddress: '0x0000000019ab540356cbb839be05303d7705fa1',
                 integratorFee: {
+                    share: Bps.fromPercent(50),
                     receiver: Address.fromBigInt(10n),
                     value: new Bps(1n)
                 }
@@ -63,13 +67,14 @@ describe(__filename, function() {
                 amount: 'dasdad',
                 walletAddress: '0x00000000219ab540356cbb839cbe05303d7705fa',
                 integratorFee: {
+                    share: Bps.fromPercent(50),
                     receiver: Address.fromBigInt(10n),
                     value: new Bps(1n)
                 }
             });
         }).toThrow(/is invalid amount/);
     });
-    it('allows fee without source', function() {
+    it('returns error if  fee is provided and source not', function() {
         expect(function() {
             return QuoterRequest.new({
                 fromTokenAddress: '0x6b175474e89094c44da98b954eedeac495271d0f',
@@ -77,10 +82,11 @@ describe(__filename, function() {
                 amount: '1000000',
                 walletAddress: '0x00000000219ab540356cbb839cbe05303d7705fa',
                 integratorFee: {
+                    share: Bps.fromPercent(50),
                     receiver: Address.fromBigInt(10n),
                     value: new Bps(1n)
                 }
             });
-        }).not.toThrow();
+        }).toThrow(/cannot use fee without source/);
     });
 });

package/dist/esm/constants.js

@@ -1,3 +1,16 @@
+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;
+}
 export var ZX = '0x';
 export var NetworkEnum = /*#__PURE__*/ function(NetworkEnum) {
     NetworkEnum[NetworkEnum["ETHEREUM"] = 1] = "ETHEREUM";
@@ -15,7 +28,8 @@ export var NetworkEnum = /*#__PURE__*/ function(NetworkEnum) {
     NetworkEnum[NetworkEnum["UNICHAIN"] = 130] = "UNICHAIN";
     return NetworkEnum;
 }({});
-export var ONE_INCH_LIMIT_ORDER_V4 = '0x111111125421ca6dc452d289314280a0f8842a65';
+var _obj;
+export var ONE_INCH_LIMIT_ORDER_V4_ADDRESSES = (_obj = {}, _define_property(_obj, 324, '0x6fd4383cb451173d5f9304f041c7bcbf27d561ff'), _define_property(_obj, 1, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 137, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 56, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 42161, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 43114, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 10, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 250, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 100, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 8453, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 59144, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 146, '0x111111125421ca6dc452d289314280a0f8842a65'), _define_property(_obj, 130, '0x111111125421ca6dc452d289314280a0f8842a65'), _obj);
 export var UINT_160_MAX = (1n << 160n) - 1n;
 export var UINT_16_MAX = (1n << 16n) - 1n;
 export var UINT_80_MAX = (1n << 80n) - 1n;

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

@@ -30,6 +30,13 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -69,11 +76,15 @@ function _object_spread_props(target, source) {
     }
     return target;
 }
-import { Address, Interaction, LimitOrder, MakerTraits } from '@1inch/limit-order-sdk';
+import { Address, Extension, Interaction, LimitOrder, MakerTraits, randBigInt } from '@1inch/limit-order-sdk';
+import { UINT_256_MAX } from '@1inch/byte-utils';
 import assert from 'assert';
 import { FusionExtension } from './fusion-extension.js';
 import { injectTrackCode } from './source-track.js';
 import { SurplusParams } from './surplus-params.js';
+import { PermitTransferFrom } from './permit/permit-transfer-from.js';
+import { getPermit2ProxyAddress } from './permit/utils.js';
+import { decodeTransferFromSuffix } from './permit/transfer-from-suffix.js';
 import { AuctionCalculator } from '../amount-calculator/auction-calculator/index.js';
 import { ZX } from '../constants.js';
 import { calcTakingAmount } from '../utils/amounts.js';
@@ -162,6 +173,9 @@ export var FusionOrder = /*#__PURE__*/ function() {
         {
             key: "makerAsset",
             get: function get() {
+                if (this.isTransferPermit()) {
+                    return this.decodeTransferPermitSuffix().token;
+                }
                 return this.inner.makerAsset;
             }
         },
@@ -258,6 +272,48 @@ export var FusionOrder = /*#__PURE__*/ function() {
                 return this.inner.salt;
             }
         },
+        {
+            key: "isTransferPermit",
+            value: /**
+     * Returns true if the order uses a Permit2 transfer permit via Permit2Proxy.
+     * Decodes `makerAssetSuffix` and validates the Permit2 ABI structure.
+     *
+     * @see FusionOrder.withTransferPermit
+     * @see FusionOrder.createTransferPermit
+     */ function isTransferPermit() {
+                try {
+                    this.decodeTransferPermitSuffix();
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            }
+        },
+        {
+            key: "withTransferPermit",
+            value: function withTransferPermit(permit, signature) {
+                var suffix = permit.getTransferFromSuffix(signature);
+                var currentExtension = this.inner.extension;
+                var newExtension = new Extension(_object_spread_props(_object_spread({}, currentExtension), {
+                    makerAssetSuffix: suffix
+                }));
+                this.inner.makerTraits.disablePermit2();
+                var baseSalt = this.inner.salt >> 160n;
+                var newSalt = LimitOrder.buildSalt(newExtension, baseSalt);
+                this.inner = new LimitOrder({
+                    maker: this.inner.maker,
+                    makerAsset: permit.spender,
+                    takerAsset: this.inner.takerAsset,
+                    makingAmount: this.inner.makingAmount,
+                    takingAmount: this.inner.takingAmount,
+                    receiver: this.inner.receiver,
+                    salt: newSalt
+                }, this.inner.makerTraits, newExtension, {
+                    optimizeReceiverAddress: false
+                });
+                return this;
+            }
+        },
         {
             key: "build",
             value: function build() {
@@ -453,6 +509,67 @@ export var FusionOrder = /*#__PURE__*/ function() {
      */ function nativeSignature(maker) {
                 return this.inner.nativeSignature(maker);
             }
+        },
+        {
+            key: "createTransferPermit",
+            value: /**
+     * Creates a Permit2 `PermitTransferFrom` object for the order's maker asset.
+     *
+     * Can only be used for orders where `multipleFillsAllowed` is `false`.
+     *
+     * The returned permit authorizes the `permit2Proxy` address (as spender)
+     * to transfer up to `makingAmount` of the `makerAsset` token,
+     * with a random 256-bit nonce and the order's deadline.
+     *
+     * The resulting permit can be signed and then attached to the order
+     * via {@link FusionOrder.withTransferPermit}.
+     *
+     * @param chainId - The chain ID used to resolve the default Permit2Proxy address
+     * @param permit2Proxy - Optional address of the Permit2Proxy contract that will act as spender.
+     *                       Defaults to the built-in address for the given `chainId`.
+     * @returns A {@link PermitTransferFrom} instance that can be signed and attached to the order
+     *
+     * @throws If `multipleFillsAllowed` is `true`
+     *
+     * @see FusionOrder.withTransferPermit
+     */ function createTransferPermit(chainIdOrPermit2Proxy, permit2Proxy) {
+                assert(!this.multipleFillsAllowed, 'transfer permit can be used only for orders where multipleFillsAllowed=false');
+                var spender = _instanceof(chainIdOrPermit2Proxy, Address) ? chainIdOrPermit2Proxy : permit2Proxy !== null && permit2Proxy !== void 0 ? permit2Proxy : getPermit2ProxyAddress(chainIdOrPermit2Proxy);
+                return new PermitTransferFrom(this.makerAsset, this.makingAmount, spender, randBigInt(UINT_256_MAX), this.deadline);
+            }
+        },
+        {
+            key: "restoreMakerAssetSuffix",
+            value: /**
+     * Restores the original `makerAssetSuffix` that `FusionExtension.build()` does not preserve.
+     * Recomputes the salt to match the patched extension hash.
+     */ function restoreMakerAssetSuffix(makerAssetSuffix) {
+                var patchedExtension = new Extension(_object_spread_props(_object_spread({}, this.inner.extension), {
+                    makerAssetSuffix: makerAssetSuffix
+                }));
+                var baseSalt = this.inner.salt >> 160n;
+                this.inner = new LimitOrder({
+                    maker: this.inner.maker,
+                    makerAsset: this.inner.makerAsset,
+                    takerAsset: this.inner.takerAsset,
+                    makingAmount: this.inner.makingAmount,
+                    takingAmount: this.inner.takingAmount,
+                    receiver: this.inner.receiver,
+                    salt: LimitOrder.buildSalt(patchedExtension, baseSalt)
+                }, this.inner.makerTraits, patchedExtension, {
+                    optimizeReceiverAddress: false
+                });
+            }
+        },
+        {
+            key: "decodeTransferPermitSuffix",
+            value: function decodeTransferPermitSuffix() {
+                var suffix = this.inner.extension.makerAssetSuffix;
+                if (suffix === ZX) {
+                    throw new Error('no makerAssetSuffix');
+                }
+                return decodeTransferFromSuffix(suffix);
+            }
         }
     ], [
         {
@@ -532,6 +649,9 @@ export var FusionOrder = /*#__PURE__*/ function() {
                     fees: extra === null || extra === void 0 ? void 0 : extra.fees,
                     optimizeReceiverAddress: true
                 });
+                if (extension.makerAssetSuffix !== ZX) {
+                    fusionOrder.restoreMakerAssetSuffix(extension.makerAssetSuffix);
+                }
                 assert(providedSalt === fusionOrder.salt, 'invalid salt for passed extension');
                 return fusionOrder;
             }

package/dist/esm/fusion-order/fusion-order.spec.js

@@ -461,4 +461,104 @@ describe('FusionOrder Native', function() {
         });
         expect(nativeOrder.build().receiver).toEqual(settlementExt.toString());
     });
+    describe('isTransferPermit', function() {
+        var extensionContract = new Address('0x8273f37417da37c4a6c3995e82cf442f87a25d9c');
+        var permit2Proxy = new Address('0x1234567890abcdef1234567890abcdef12345678');
+        var baseOrder = function() {
+            return FusionOrder.new(extensionContract, {
+                makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+                takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+                makingAmount: parseEther('1'),
+                takingAmount: parseUnits('1000', 6),
+                maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa')
+            }, {
+                auction: new AuctionDetails({
+                    duration: 180n,
+                    startTime: 1673548149n,
+                    initialRateBump: 0,
+                    points: []
+                }),
+                whitelist: Whitelist.new(1673548139n, [
+                    {
+                        address: new Address('0x00000000219ab540356cbb839cbe05303d7705fa'),
+                        allowFrom: 0n
+                    }
+                ]),
+                surplus: SurplusParams.NO_FEE
+            }, {
+                allowPartialFills: false,
+                allowMultipleFills: false,
+                nonce: 1n
+            });
+        };
+        it('should return false for regular order', function() {
+            var order = FusionOrder.new(extensionContract, {
+                makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+                takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+                makingAmount: parseEther('1'),
+                takingAmount: parseUnits('1000', 6),
+                maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa')
+            }, {
+                auction: new AuctionDetails({
+                    duration: 180n,
+                    startTime: 1673548149n,
+                    initialRateBump: 0,
+                    points: []
+                }),
+                whitelist: Whitelist.new(1673548139n, [
+                    {
+                        address: new Address('0x00000000219ab540356cbb839cbe05303d7705fa'),
+                        allowFrom: 0n
+                    }
+                ]),
+                surplus: SurplusParams.NO_FEE
+            });
+            expect(order.isTransferPermit()).toBe(false);
+        });
+        it('should return true after withTransferPermit', function() {
+            var order = baseOrder();
+            var permit = order.createTransferPermit(permit2Proxy);
+            var fakeSignature = '0x' + 'ab'.repeat(65);
+            var orderWithPermit = order.withTransferPermit(permit, fakeSignature);
+            expect(orderWithPermit.isTransferPermit()).toBe(true);
+        });
+        it('should return real token as makerAsset after withTransferPermit', function() {
+            var weth = new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2');
+            var order = baseOrder();
+            var permit = order.createTransferPermit(permit2Proxy);
+            var fakeSignature = '0x' + 'ab'.repeat(65);
+            var orderWithPermit = order.withTransferPermit(permit, fakeSignature);
+            expect(orderWithPermit.makerAsset).toEqual(weth);
+        });
+        it('should round-trip Permit2 order through fromDataAndExtension', function() {
+            var order = baseOrder();
+            var permit = order.createTransferPermit(permit2Proxy);
+            var fakeSignature = '0x' + 'ab'.repeat(65);
+            var orderWithPermit = order.withTransferPermit(permit, fakeSignature);
+            var built = orderWithPermit.build();
+            var rebuilt = FusionOrder.fromDataAndExtension(built, orderWithPermit.extension);
+            expect(rebuilt.isTransferPermit()).toBe(true);
+            expect(rebuilt.makerAsset).toEqual(orderWithPermit.makerAsset);
+            expect(rebuilt.salt).toEqual(orderWithPermit.salt);
+            expect(rebuilt.build()).toEqual(built);
+        });
+        it('should reject tampered makerAssetSuffix via salt check', function() {
+            var order = baseOrder();
+            var ext = order.extension;
+            var tampered = new Extension({
+                makerAssetSuffix: '0xdeadbeef',
+                takerAssetSuffix: ext.takerAssetSuffix,
+                makingAmountData: ext.makingAmountData,
+                takingAmountData: ext.takingAmountData,
+                predicate: ext.predicate,
+                makerPermit: ext.makerPermit,
+                preInteraction: ext.preInteraction,
+                postInteraction: ext.postInteraction,
+                customData: ext.customData
+            });
+            expect(function() {
+                return FusionOrder.fromDataAndExtension(order.build(), tampered);
+            }).toThrow('invalid salt for passed extension');
+        });
+    });
 });

package/dist/esm/fusion-order/index.js

@@ -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/esm/fusion-order/permit/constants.js

@@ -0,0 +1,71 @@
+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;
+}
+import { NetworkEnum } from '../../constants.js';
+var PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
+var PERMIT2_ADDRESS_ZK = '0x0000000000225e31d15943971f47ad3022f714fa';
+var _obj;
+export var PERMIT2_ADDRESSES = (_obj = {}, _define_property(_obj, NetworkEnum.ZKSYNC, PERMIT2_ADDRESS_ZK), _define_property(_obj, NetworkEnum.ARBITRUM, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.ETHEREUM, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.POLYGON, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.BINANCE, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.AVALANCHE, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.OPTIMISM, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.FANTOM, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.GNOSIS, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.COINBASE, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.LINEA, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.SONIC, PERMIT2_ADDRESS), _define_property(_obj, NetworkEnum.UNICHAIN, PERMIT2_ADDRESS), _obj);
+// todo: update
+var PERMIT2_PROXY_ADDRESS = '0xcf56da25062c954b252515244dfefb739c254c23';
+var PERMIT2_PROXY_ADDRESS_ZK = '0x0000000000000000000000000000000000000000';
+var _obj1;
+export var PERMIT2_PROXY_ADDRESSES = (_obj1 = {}, _define_property(_obj1, NetworkEnum.ZKSYNC, PERMIT2_PROXY_ADDRESS_ZK), _define_property(_obj1, NetworkEnum.ARBITRUM, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.ETHEREUM, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.POLYGON, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.BINANCE, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.AVALANCHE, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.OPTIMISM, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.FANTOM, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.GNOSIS, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.COINBASE, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.LINEA, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.SONIC, PERMIT2_PROXY_ADDRESS), _define_property(_obj1, NetworkEnum.UNICHAIN, PERMIT2_PROXY_ADDRESS), _obj1);
+export var PERMIT2_DOMAIN_NAME = 'Permit2';
+export var TOKEN_PERMISSIONS = {
+    TokenPermissions: [
+        {
+            name: 'token',
+            type: 'address'
+        },
+        {
+            name: 'amount',
+            type: 'uint256'
+        }
+    ]
+};
+export var PERMIT_TRANSFER_FROM_TYPES = _object_spread({
+    PermitTransferFrom: [
+        {
+            name: 'permitted',
+            type: 'TokenPermissions'
+        },
+        {
+            name: 'spender',
+            type: 'address'
+        },
+        {
+            name: 'nonce',
+            type: 'uint256'
+        },
+        {
+            name: 'deadline',
+            type: 'uint256'
+        }
+    ]
+}, TOKEN_PERMISSIONS);

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

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

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

@@ -0,0 +1,105 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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;
+}
+import { PERMIT2_DOMAIN_NAME, PERMIT_TRANSFER_FROM_TYPES } from './constants.js';
+import { getPermit2Address } from './utils.js';
+import { encodeTransferFromSuffix } from './transfer-from-suffix.js';
+export var PermitTransferFrom = /*#__PURE__*/ function() {
+    "use strict";
+    function PermitTransferFrom(token, maxSpendAmount, spender, nonce, deadline) {
+        _class_call_check(this, PermitTransferFrom);
+        _define_property(this, "token", void 0);
+        _define_property(this, "maxSpendAmount", void 0);
+        _define_property(this, "spender", void 0);
+        _define_property(this, "nonce", void 0);
+        _define_property(this, "deadline", void 0);
+        this.token = token;
+        this.maxSpendAmount = maxSpendAmount;
+        this.spender = spender;
+        this.nonce = nonce;
+        this.deadline = deadline;
+    }
+    _create_class(PermitTransferFrom, [
+        {
+            key: "getTypedData",
+            value: function getTypedData(chainId) {
+                var permit2Address = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getPermit2Address(chainId);
+                return {
+                    primaryType: 'PermitTransferFrom',
+                    types: _object_spread({}, PERMIT_TRANSFER_FROM_TYPES),
+                    domain: {
+                        name: PERMIT2_DOMAIN_NAME,
+                        chainId: chainId,
+                        verifyingContract: permit2Address
+                    },
+                    message: {
+                        permitted: {
+                            token: this.token.toString(),
+                            amount: this.maxSpendAmount
+                        },
+                        spender: this.spender.toString(),
+                        nonce: this.nonce,
+                        deadline: this.deadline
+                    }
+                };
+            }
+        },
+        {
+            key: "getTransferFromSuffix",
+            value: /**
+     * ABI-encodes the Permit2 suffix appended to `transferFrom(from,to,amount)` calldata.
+     *
+     * The limit order protocol calls `_callTransferFromWithSuffix` on the Permit2Proxy,
+     * which has `func_nZHTch(address,address,uint256,((address,uint256),uint256,uint256),bytes)`
+     * with selector 0x23b872dd (same as transferFrom). The suffix is everything after (from,to,amount).
+     */ function getTransferFromSuffix(signature) {
+                return encodeTransferFromSuffix(this.token, this.maxSpendAmount, this.nonce, this.deadline, signature);
+            }
+        }
+    ]);
+    return PermitTransferFrom;
+}();