@morpho-org/blue-sdk 1.0.2 → 1.0.4

package/lib/notifications.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProducer = exports.NotificationTopic = exports.NotificationStatus = void 0;
+const rxjs_1 = require("rxjs");
+var NotificationStatus;
+(function (NotificationStatus) {
+    NotificationStatus["signing"] = "signing";
+    NotificationStatus["success"] = "success";
+    NotificationStatus["error"] = "error";
+    NotificationStatus["pending"] = "pending";
+})(NotificationStatus || (exports.NotificationStatus = NotificationStatus = {}));
+var NotificationTopic;
+(function (NotificationTopic) {
+    NotificationTopic["tx"] = "tx";
+    NotificationTopic["signature"] = "signature";
+})(NotificationTopic || (exports.NotificationTopic = NotificationTopic = {}));
+/**
+ * MUST receive a success or error notification at some point to ensure the result promise resolves.
+ */
+class NotificationProducer {
+    /**
+     * Creates a notification producer.
+     * MUST receive a success or error notification at some point to ensure the result promise resolves.
+     * @param topic The notification topic to populate each notification with.
+     */
+    constructor(topic) {
+        this.topic = topic;
+        this._notifications$ = new rxjs_1.ReplaySubject(Infinity);
+        this.notifications$ = this._notifications$.asObservable();
+        this._result = (0, rxjs_1.lastValueFrom)(this._notifications$);
+        this.consumer = {
+            notifications$: this.notifications$,
+            wait: this.wait.bind(this),
+        };
+    }
+    async wait(observerOrNext) {
+        const subscription = this.notifications$.subscribe(observerOrNext);
+        const notification = (await this._result);
+        subscription.unsubscribe();
+        return notification;
+    }
+    next(notification) {
+        this._notifications$.next({
+            ...notification,
+            topic: this.topic,
+        });
+        if (notification.status === NotificationStatus.success ||
+            notification.status === NotificationStatus.error)
+            this._notifications$.complete();
+    }
+}
+exports.NotificationProducer = NotificationProducer;

package/lib/position/Position.d.ts

@@ -0,0 +1,118 @@
+import { BigNumberish, Provider } from "ethers";
+import { ViewOverrides } from "ethers-types/dist/common";
+import { ChainId } from "../chain";
+import { Market, MarketConfig } from "../market";
+import { Address, MarketId } from "../types";
+export interface InputPosition {
+    user: Address;
+    marketId: MarketId;
+    supplyShares: BigNumberish;
+    borrowShares: BigNumberish;
+    collateral: BigNumberish;
+}
+export declare class Position implements InputPosition {
+    static fetch(user: Address, marketId: MarketId, runner: {
+        provider: Provider;
+    }, { chainId, overrides, }?: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<Position>;
+    /**
+     * The user holding this position.
+     */
+    readonly user: Address;
+    /**
+     * The id of the market on which this position is held.
+     */
+    readonly marketId: MarketId;
+    /**
+     * The amount of supply shares held with this position.
+     */
+    supplyShares: bigint;
+    /**
+     * The amount of borrow shares held with this position.
+     */
+    borrowShares: bigint;
+    /**
+     * The amount of collateral assets held with this position.
+     */
+    collateral: bigint;
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }: InputPosition);
+}
+export interface InputAccrualPosition extends Omit<InputPosition, "marketId"> {
+}
+export declare class AccrualPosition extends Position implements InputAccrualPosition {
+    static fetchFromId(user: Address, marketId: MarketId, runner: {
+        provider: Provider;
+    }, options: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<AccrualPosition>;
+    static fetchFromConfig(user: Address, config: MarketConfig, runner: {
+        provider: Provider;
+    }, options: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<AccrualPosition>;
+    /**
+     * The market on which this position is held.
+     */
+    readonly market: Market;
+    constructor(position: InputAccrualPosition, market: Market);
+    get supplyAssets(): bigint;
+    get borrowAssets(): bigint;
+    /**
+     * The value of this position's collateral quoted in loan assets.
+     */
+    get collateralValue(): bigint;
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowAssets(): bigint;
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowableAssets(): bigint;
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     */
+    get seizableCollateral(): bigint;
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     */
+    get withdrawableCollateral(): bigint;
+    /**
+     * Whether this position is healthy.
+     */
+    get isHealthy(): boolean;
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     */
+    get liquidationPrice(): bigint | null;
+    /**
+     * The variation of the price of the collateral quoted in loan assets that would allow this position to be liquidated,
+     * relative to the current collateral price (scaled by WAD).
+     */
+    get priceVariationToLiquidation(): bigint | null;
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     */
+    get ltv(): bigint | null;
+    /**
+     * This position's health factor (collateral power over debt, scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     */
+    get healthFactor(): bigint | null;
+    /**
+     * The percentage of this position's borrow power currently used (scaled by WAD).
+     * If the collateral price is 0, usage is `MaxUint256`.
+     */
+    get borrowCapacityUsage(): bigint | null;
+    get borrowCapacityLimit(): import("../market").CapacityLimit;
+    get withdrawCapacityLimit(): import("../market").CapacityLimit;
+    get withdrawCollateralCapacityLimit(): import("../market").CapacityLimit;
+    accrueInterest(timestamp: BigNumberish): AccrualPosition;
+    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market").CapacityLimit;
+    getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint): import("../market").MaxPositionCapacities;
+}

package/lib/position/Position.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualPosition = exports.Position = void 0;
+const ethers_1 = require("ethers");
+const ethers_types_1 = require("ethers-types");
+const addresses_1 = require("../addresses");
+const chain_1 = require("../chain");
+const market_1 = require("../market");
+class Position {
+    static async fetch(user, marketId, runner, { chainId, overrides = {}, } = {}) {
+        chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
+        const { morpho } = (0, addresses_1.getChainAddresses)(chainId);
+        const { supplyShares, borrowShares, collateral } = await ethers_types_1.MorphoBlue__factory.connect(morpho, runner).position(marketId, user, overrides);
+        return new Position({
+            user,
+            marketId,
+            supplyShares,
+            borrowShares,
+            collateral,
+        });
+    }
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }) {
+        this.user = user;
+        this.marketId = marketId;
+        this.supplyShares = (0, ethers_1.toBigInt)(supplyShares);
+        this.borrowShares = (0, ethers_1.toBigInt)(borrowShares);
+        this.collateral = (0, ethers_1.toBigInt)(collateral);
+    }
+}
+exports.Position = Position;
+class AccrualPosition extends Position {
+    static async fetchFromId(user, marketId, runner, options) {
+        const [position, market] = await Promise.all([
+            await Position.fetch(user, marketId, runner, options),
+            await market_1.Market.fetchFromId(marketId, runner, options),
+        ]);
+        return new AccrualPosition(position, market);
+    }
+    static async fetchFromConfig(user, config, runner, options) {
+        const [position, market] = await Promise.all([
+            await Position.fetch(user, config.id, runner, options),
+            await market_1.Market.fetchFromConfig(config, runner, options),
+        ]);
+        return new AccrualPosition(position, market);
+    }
+    constructor(position, market) {
+        super({ ...position, marketId: market.id });
+        this.market = market;
+    }
+    get supplyAssets() {
+        return this.market.toSupplyAssets(this.supplyShares);
+    }
+    get borrowAssets() {
+        return this.market.toBorrowAssets(this.borrowShares);
+    }
+    /**
+     * The value of this position's collateral quoted in loan assets.
+     */
+    get collateralValue() {
+        return this.market.getCollateralValue(this.collateral);
+    }
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowAssets() {
+        return this.market.getMaxBorrowAssets(this.collateral);
+    }
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowableAssets() {
+        return this.market.getMaxBorrowableAssets(this);
+    }
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     */
+    get seizableCollateral() {
+        return this.market.getSeizableCollateral(this);
+    }
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     */
+    get withdrawableCollateral() {
+        return this.market.getWithdrawableCollateral(this);
+    }
+    /**
+     * Whether this position is healthy.
+     */
+    get isHealthy() {
+        return this.market.isHealthy(this);
+    }
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     */
+    get liquidationPrice() {
+        return this.market.getLiquidationPrice(this);
+    }
+    /**
+     * The variation of the price of the collateral quoted in loan assets that would allow this position to be liquidated,
+     * relative to the current collateral price (scaled by WAD).
+     */
+    get priceVariationToLiquidation() {
+        return this.market.getPriceVariationToLiquidation(this);
+    }
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     */
+    get ltv() {
+        return this.market.getLtv(this);
+    }
+    /**
+     * This position's health factor (collateral power over debt, scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     */
+    get healthFactor() {
+        return this.market.getHealthFactor(this);
+    }
+    /**
+     * The percentage of this position's borrow power currently used (scaled by WAD).
+     * If the collateral price is 0, usage is `MaxUint256`.
+     */
+    get borrowCapacityUsage() {
+        return this.market.getBorrowCapacityUsage(this);
+    }
+    get borrowCapacityLimit() {
+        return this.market.getBorrowCapacityLimit(this.collateral);
+    }
+    get withdrawCapacityLimit() {
+        return this.market.getWithdrawCapacityLimit(this.supplyShares);
+    }
+    get withdrawCollateralCapacityLimit() {
+        return this.market.getWithdrawCollateralCapacityLimit(this);
+    }
+    accrueInterest(timestamp) {
+        return new AccrualPosition(this, this.market.accrueInterest(timestamp));
+    }
+    getRepayCapacityLimit(loanTokenBalance) {
+        return this.market.getRepayCapacityLimit(this.borrowShares, loanTokenBalance);
+    }
+    getMaxCapacities(loanTokenBalance, collateralTokenBalance) {
+        return this.market.getMaxCapacities(this, loanTokenBalance, collateralTokenBalance);
+    }
+}
+exports.AccrualPosition = AccrualPosition;

package/lib/position/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Position"), exports);

package/lib/signatures/index.d.ts

@@ -0,0 +1,12 @@
+import * as _Manager from "./manager";
+import * as _Permit from "./permit";
+import * as _Permit2 from "./permit2";
+import { safeSignTypedData as _safeSignTypedData, verifySignature as _verifySignature, getMessage as _getMessage } from "./utils";
+export declare namespace SignatureUtils {
+    export import Permit = _Permit;
+    export import Permit2 = _Permit2;
+    export import Manager = _Manager;
+    const safeSignTypedData: typeof _safeSignTypedData;
+    const verifySignature: typeof _verifySignature;
+    const getMessage: typeof _getMessage;
+}

package/lib/signatures/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureUtils = void 0;
+const _Manager = __importStar(require("./manager"));
+const _Permit = __importStar(require("./permit"));
+const _Permit2 = __importStar(require("./permit2"));
+const utils_1 = require("./utils");
+var SignatureUtils;
+(function (SignatureUtils) {
+    SignatureUtils.Permit = _Permit;
+    SignatureUtils.Permit2 = _Permit2;
+    SignatureUtils.Manager = _Manager;
+    SignatureUtils.safeSignTypedData = utils_1.safeSignTypedData;
+    SignatureUtils.verifySignature = utils_1.verifySignature;
+    SignatureUtils.getMessage = utils_1.getMessage;
+})(SignatureUtils || (exports.SignatureUtils = SignatureUtils = {}));

package/lib/signatures/manager.d.ts

@@ -0,0 +1,10 @@
+import { ChainId } from "../chain";
+import { SignatureMessage } from "./types";
+export interface ManagerApprovalSignatureArgs {
+    authorizer: string;
+    authorized: string;
+    isAuthorized: boolean;
+    nonce: bigint;
+    deadline: bigint;
+}
+export declare const getManagerApprovalMessage: (args: ManagerApprovalSignatureArgs, chainId: ChainId) => SignatureMessage;

package/lib/signatures/manager.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManagerApprovalMessage = void 0;
+const addresses_1 = require("../addresses");
+const utils_1 = require("./utils");
+const getManagerApprovalMessage = (args, chainId) => {
+    const domain = {
+        chainId: chainId.toString(),
+        verifyingContract: (0, addresses_1.getChainAddresses)(chainId).morpho,
+    };
+    const types = {
+        Authorization: [
+            {
+                name: "authorizer",
+                type: "address",
+            },
+            {
+                name: "authorized",
+                type: "address",
+            },
+            {
+                name: "isAuthorized",
+                type: "bool",
+            },
+            {
+                name: "nonce",
+                type: "uint256",
+            },
+            {
+                name: "deadline",
+                type: "uint256",
+            },
+        ],
+    };
+    return (0, utils_1.getMessage)(domain, types, args);
+};
+exports.getManagerApprovalMessage = getManagerApprovalMessage;

package/lib/signatures/permit.d.ts

@@ -0,0 +1,21 @@
+import { ChainId } from "../chain";
+import { Token } from "../token";
+import { Address } from "../types";
+import { SignatureMessage } from "./types";
+export interface PermitArgs {
+    erc20: Token;
+    owner: Address;
+    spender: Address;
+    allowance: bigint;
+    nonce: bigint;
+    deadline: bigint;
+}
+/**
+ * Permit signature for ERC20 tokens, following EIP-2612.
+ * Docs: https://eips.ethereum.org/EIPS/eip-2612
+ */
+export declare const getPermitMessage: ({ deadline, owner, nonce, spender, erc20, allowance }: PermitArgs, chainId: ChainId) => SignatureMessage;
+export declare const WITH_SIMPLE_PERMIT: {
+    [id in ChainId]: (Address | undefined)[];
+};
+export declare const hasSimplePermit: (chainId: ChainId, address: Address) => boolean;

package/lib/signatures/permit.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSimplePermit = exports.WITH_SIMPLE_PERMIT = exports.getPermitMessage = void 0;
+const addresses_1 = require("../addresses");
+const chain_1 = require("../chain");
+const utils_1 = require("./utils");
+/**
+ * Permit signature for ERC20 tokens, following EIP-2612.
+ * Docs: https://eips.ethereum.org/EIPS/eip-2612
+ */
+const getPermitMessage = ({ deadline, owner, nonce, spender, erc20, allowance }, chainId) => {
+    const { usdc, dai } = (0, addresses_1.getChainAddresses)(chainId);
+    const domain = {
+        name: erc20.name,
+        version: erc20.address === usdc ? "2" : "1",
+        chainId: chainId.toString(),
+        verifyingContract: erc20.address,
+    };
+    if (erc20.address === dai)
+        return (0, utils_1.getMessage)(domain, {
+            Permit: [
+                {
+                    name: "holder",
+                    type: "address",
+                },
+                {
+                    name: "spender",
+                    type: "address",
+                },
+                {
+                    name: "nonce",
+                    type: "uint256",
+                },
+                {
+                    name: "expiry",
+                    type: "uint256",
+                },
+                {
+                    name: "allowed",
+                    type: "bool",
+                },
+            ],
+        }, {
+            holder: owner,
+            spender,
+            allowed: allowance > 0n,
+            nonce,
+            expiry: deadline,
+        });
+    const types = {
+        Permit: [
+            {
+                name: "owner",
+                type: "address",
+            },
+            {
+                name: "spender",
+                type: "address",
+            },
+            {
+                name: "value",
+                type: "uint256",
+            },
+            {
+                name: "nonce",
+                type: "uint256",
+            },
+            {
+                name: "deadline",
+                type: "uint256",
+            },
+        ],
+    };
+    const value = {
+        owner,
+        spender,
+        value: allowance,
+        nonce,
+        deadline,
+    };
+    return (0, utils_1.getMessage)(domain, types, value);
+};
+exports.getPermitMessage = getPermitMessage;
+exports.WITH_SIMPLE_PERMIT = {
+    [chain_1.ChainId.EthMainnet]: [
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].wbIB01,
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].wbC3M,
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].wstEth,
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].sDai,
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].osEth,
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].usdc,
+        addresses_1.addresses[chain_1.ChainId.EthMainnet].dai,
+    ],
+    [chain_1.ChainId.EthGoerliTestnet]: [
+        "0x0aCd15Fb54034492c392596B56ED415bD07e70d7", // Fake DAI
+        "0xD8134205b0328F5676aaeFb3B2a0DC15f4029d8C", // Real sDAI
+    ],
+    [chain_1.ChainId.BaseMainnet]: [addresses_1.addresses[chain_1.ChainId.BaseMainnet].usdc],
+};
+const hasSimplePermit = (chainId, address) => exports.WITH_SIMPLE_PERMIT[chainId]?.includes(address);
+exports.hasSimplePermit = hasSimplePermit;

package/lib/signatures/permit2.d.ts

@@ -0,0 +1,20 @@
+import { ChainId } from "../chain";
+import { Address } from "../types";
+import { SignatureMessage } from "./types";
+export interface Permit2Args {
+    erc20: Address;
+    allowance: bigint;
+    nonce: bigint;
+    deadline: bigint;
+    spender: Address;
+    expiration?: bigint;
+}
+export interface Permit2TransferFromArgs {
+    erc20: Address;
+    allowance: bigint;
+    spender: Address;
+    nonce: bigint;
+    deadline: bigint;
+}
+export declare const getPermit2TransferFromMessage: (args: Permit2TransferFromArgs, chainId: ChainId) => SignatureMessage;
+export declare const getPermit2Message: (args: Permit2Args, chainId: ChainId) => SignatureMessage;

package/lib/signatures/permit2.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermit2Message = exports.getPermit2TransferFromMessage = void 0;
+const addresses_1 = require("../addresses");
+const maths_1 = require("../maths");
+const utils_1 = require("./utils");
+const getPermit2TransferFromMessage = (args, chainId) => {
+    const domain = {
+        name: "Permit2",
+        chainId: chainId.toString(),
+        verifyingContract: (0, addresses_1.getChainAddresses)(chainId).permit2,
+    };
+    const types = {
+        PermitTransferFrom: [
+            { name: "permitted", type: "TokenPermissions" },
+            { name: "spender", type: "address" },
+            { name: "nonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+        ],
+        TokenPermissions: [
+            { name: "token", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+    };
+    const value = {
+        permitted: {
+            token: args.erc20,
+            amount: maths_1.MathLib.min(args.allowance, maths_1.MathLib.MAX_UINT_160),
+        },
+        spender: args.spender,
+        nonce: args.nonce,
+        deadline: args.deadline,
+    };
+    return (0, utils_1.getMessage)(domain, types, value);
+};
+exports.getPermit2TransferFromMessage = getPermit2TransferFromMessage;
+const getPermit2Message = (args, chainId) => {
+    const domain = {
+        name: "Permit2",
+        chainId: chainId.toString(),
+        verifyingContract: (0, addresses_1.getChainAddresses)(chainId).permit2,
+    };
+    const types = {
+        PermitSingle: [
+            {
+                name: "details",
+                type: "PermitDetails",
+            },
+            {
+                name: "spender",
+                type: "address",
+            },
+            {
+                name: "sigDeadline",
+                type: "uint256",
+            },
+        ],
+        PermitDetails: [
+            {
+                name: "token",
+                type: "address",
+            },
+            {
+                name: "amount",
+                type: "uint160",
+            },
+            {
+                name: "expiration",
+                type: "uint48",
+            },
+            {
+                name: "nonce",
+                type: "uint48",
+            },
+        ],
+    };
+    const value = {
+        details: {
+            token: args.erc20,
+            amount: maths_1.MathLib.min(args.allowance, maths_1.MathLib.MAX_UINT_160),
+            // Use an unlimited expiration because it most
+            // closely mimics how a standard approval works.
+            expiration: maths_1.MathLib.min(args.expiration ?? maths_1.MathLib.MAX_UINT_48, maths_1.MathLib.MAX_UINT_48),
+            nonce: args.nonce,
+        },
+        spender: args.spender,
+        sigDeadline: args.deadline,
+    };
+    return (0, utils_1.getMessage)(domain, types, value);
+};
+exports.getPermit2Message = getPermit2Message;

package/lib/signatures/types.d.ts

@@ -0,0 +1,13 @@
+import { TypedDataDomain } from "ethers";
+export interface SignatureData {
+    domain: TypedDataDomain;
+    types: Record<string, {
+        name: string;
+        type: string;
+    }[]>;
+    value: object;
+}
+export interface SignatureMessage {
+    hash: string;
+    data: SignatureData;
+}