@1inch/fusion-sdk 2.4.6 → 2.4.7-rc.0

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,44 @@ 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: "decodeTransferPermitSuffix",
+            value: function decodeTransferPermitSuffix() {
+                var suffix = this.inner.extension.makerAssetSuffix;
+                if (suffix === ZX) {
+                    throw new Error('no makerAssetSuffix');
+                }
+                return decodeTransferFromSuffix(suffix);
+            }
         }
     ], [
         {

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

@@ -461,4 +461,91 @@ 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 return false for non-permit2 suffix data', 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
+            });
+            var rebuilt = FusionOrder.fromDataAndExtension(order.build(), tampered);
+            expect(rebuilt.isTransferPermit()).toBe(false);
+        });
+    });
 });

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;
+}();

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
+                    ];
+            }
+        });
+    }));
+});