@morpho-org/blue-sdk 5.16.0 → 5.18.0

package/lib/esm/position/Position.js

@@ -0,0 +1,237 @@
+import { BlueErrors } from "../errors.js";
+import { Market, } from "../market/index.js";
+import { MathLib } from "../math/MathLib.js";
+import { CapacityLimitReason } from "../utils.js";
+export class Position {
+    /**
+     * The user holding this position.
+     */
+    user;
+    /**
+     * The id of the market on which this position is held.
+     */
+    marketId;
+    /**
+     * The amount of supply shares held with this position.
+     */
+    supplyShares;
+    /**
+     * The amount of borrow shares held with this position.
+     */
+    borrowShares;
+    /**
+     * The amount of collateral assets held with this position.
+     */
+    collateral;
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }) {
+        this.user = user;
+        this.marketId = marketId;
+        this.supplyShares = supplyShares;
+        this.borrowShares = borrowShares;
+        this.collateral = collateral;
+    }
+}
+export class AccrualPosition extends Position {
+    _market;
+    constructor(position, market) {
+        const _market = new Market(market);
+        super({ ...position, marketId: _market.id });
+        this._market = _market;
+    }
+    /**
+     * The market on which this position is held.
+     */
+    get market() {
+        return this._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.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get collateralValue() {
+        return this._market.getCollateralValue(this.collateral);
+    }
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get maxBorrowAssets() {
+        return this._market.getMaxBorrowAssets(this.collateral);
+    }
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get maxBorrowableAssets() {
+        const { maxBorrowAssets } = this;
+        if (maxBorrowAssets == null)
+            return;
+        return MathLib.zeroFloorSub(maxBorrowAssets, this.borrowAssets);
+    }
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get seizableCollateral() {
+        return this._market.getSeizableCollateral(this);
+    }
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get withdrawableCollateral() {
+        return this._market.getWithdrawableCollateral(this);
+    }
+    /**
+     * Whether this position is healthy.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get isHealthy() {
+        return this._market.isHealthy(this);
+    }
+    /**
+     * Whether this position can be liquidated.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get isLiquidatable() {
+        const isHealthy = this._market.isHealthy(this);
+        if (isHealthy == null)
+            return;
+        return !isHealthy;
+    }
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     * `null` if the position has no borrow.
+     */
+    get liquidationPrice() {
+        return this._market.getLiquidationPrice(this);
+    }
+    /**
+     * The price variation required for the position to reach its liquidation threshold (scaled by WAD).
+     * Negative when healthy (the price needs to drop x%), positive when unhealthy (the price needs to soar x%).
+     * `undefined` if the market's oracle is undefined or reverts.
+     * `null` if the position is not a borrow.
+     */
+    get priceVariationToLiquidationPrice() {
+        return this._market.getPriceVariationToLiquidationPrice(this);
+    }
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    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`.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    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);
+    }
+    /**
+     * Returns the maximum amount of loan assets that can be withdrawn given a certain supply position
+     * and a balance of loan assets, and the reason for the limit.
+     */
+    get withdrawCapacityLimit() {
+        return this._market.getWithdrawCapacityLimit(this);
+    }
+    /**
+     * Returns a new position derived from this position, whose interest has been accrued up to the given timestamp.
+     * @param timestamp The timestamp at which to accrue interest. Must be greater than or equal to the market's `lastUpdate`.
+     */
+    accrueInterest(timestamp) {
+        return new AccrualPosition(this, this._market.accrueInterest(timestamp));
+    }
+    supply(assets, shares, timestamp) {
+        let { _market: market } = this;
+        ({ market, assets, shares } = market.supply(assets, shares, timestamp));
+        const position = new AccrualPosition(this, market);
+        position.supplyShares += shares;
+        return { position, assets, shares };
+    }
+    withdraw(assets, shares, timestamp) {
+        let { _market: market } = this;
+        ({ market, assets, shares } = market.withdraw(assets, shares, timestamp));
+        const position = new AccrualPosition(this, market);
+        position.supplyShares -= shares;
+        if (position.supplyShares < 0n)
+            throw new BlueErrors.InsufficientPosition(position.user, position.marketId);
+        return { position, assets, shares };
+    }
+    supplyCollateral(assets) {
+        this.collateral += assets;
+        return new AccrualPosition(this, new Market(this._market));
+    }
+    withdrawCollateral(assets, timestamp) {
+        if (this._market.price == null)
+            throw new BlueErrors.UnknownOraclePrice(this.marketId);
+        const position = this.accrueInterest(timestamp);
+        position.collateral -= assets;
+        if (position.collateral < 0n)
+            throw new BlueErrors.InsufficientPosition(position.user, position.marketId);
+        if (!position.isHealthy)
+            throw new BlueErrors.InsufficientCollateral(position.user, position.marketId);
+        return position;
+    }
+    borrow(assets, shares, timestamp) {
+        let { _market: market } = this;
+        if (market.price == null)
+            throw new BlueErrors.UnknownOraclePrice(market.id);
+        ({ market, assets, shares } = market.borrow(assets, shares, timestamp));
+        const position = new AccrualPosition(this, market);
+        position.borrowShares += shares;
+        if (!position.isHealthy)
+            throw new BlueErrors.InsufficientCollateral(this.user, this.marketId);
+        return { position, assets, shares };
+    }
+    repay(assets, shares, timestamp) {
+        let { _market: market } = this;
+        ({ market, assets, shares } = market.repay(assets, shares, timestamp));
+        const position = new AccrualPosition(this, market);
+        position.borrowShares -= shares;
+        if (position.borrowShares < 0n)
+            throw new BlueErrors.InsufficientPosition(position.user, position.marketId);
+        return { position, assets, shares };
+    }
+    getBorrowCapacityLimit(options) {
+        return this._market.getBorrowCapacityLimit(this, options);
+    }
+    getWithdrawCollateralCapacityLimit(options) {
+        return this._market.getWithdrawCollateralCapacityLimit(this, options);
+    }
+    getRepayCapacityLimit(loanTokenBalance) {
+        return this._market.getRepayCapacityLimit(this.borrowShares, loanTokenBalance);
+    }
+    getMaxCapacities(loanTokenBalance, collateralTokenBalance, options) {
+        return {
+            supply: {
+                value: loanTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            },
+            withdraw: this.withdrawCapacityLimit,
+            borrow: this.getBorrowCapacityLimit(options?.borrow),
+            repay: this.getRepayCapacityLimit(loanTokenBalance),
+            supplyCollateral: {
+                value: collateralTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            },
+            withdrawCollateral: this.getWithdrawCollateralCapacityLimit(options?.withdrawCollateral),
+        };
+    }
+}

package/lib/esm/position/PreLiquidationPosition.d.ts

@@ -0,0 +1,60 @@
+import type { Address } from "viem";
+import { type IMarket, Market } from "../market/index.js";
+import type { BigIntish } from "../types.js";
+import { AccrualPosition, type IAccrualPosition } from "./Position.js";
+export interface IPreLiquidationParams {
+    preLltv: BigIntish;
+    preLCF1: BigIntish;
+    preLCF2: BigIntish;
+    preLIF1: BigIntish;
+    preLIF2: BigIntish;
+    preLiquidationOracle: Address;
+}
+export declare class PreLiquidationParams implements IPreLiquidationParams {
+    readonly preLltv: bigint;
+    readonly preLCF1: bigint;
+    readonly preLCF2: bigint;
+    readonly preLIF1: bigint;
+    readonly preLIF2: bigint;
+    readonly preLiquidationOracle: `0x${string}`;
+    constructor({ preLltv, preLCF1, preLCF2, preLIF1, preLIF2, preLiquidationOracle, }: IPreLiquidationParams);
+    getCloseFactor(quotient: BigIntish): bigint;
+    getIncentiveFactor(quotient: BigIntish): bigint;
+}
+export interface IPreLiquidationPosition extends IAccrualPosition {
+    /**
+     * The pre-liquidation parameters of the associated PreLiquidation contract.
+     */
+    preLiquidationParams: IPreLiquidationParams;
+    /**
+     * The address of the PreLiquidation contract this position is associated to.
+     */
+    preLiquidation: Address;
+    /**
+     * The price of the collateral quoted in loan assets used by the PreLiquidation contract.
+     * `undefined` if the oracle reverts.
+     */
+    preLiquidationOraclePrice?: BigIntish;
+}
+export declare class PreLiquidationPosition extends AccrualPosition implements IPreLiquidationPosition {
+    readonly preLiquidationParams: PreLiquidationParams;
+    readonly preLiquidation: `0x${string}`;
+    readonly preLiquidationOraclePrice?: bigint;
+    protected readonly _baseMarket: Market;
+    constructor({ preLiquidationParams, preLiquidation, preLiquidationOraclePrice, ...position }: IPreLiquidationPosition, market: IMarket);
+    get market(): Market;
+    protected get _lltv(): bigint;
+    /**
+     * @inheritdoc `undefined` if the pre-liquidation's oracle reverts.
+     * `undefined` if it may be liquidatable on Morpho.
+     */
+    get isHealthy(): boolean | undefined;
+    /**
+     * @inheritdoc `undefined` if the pre-liquidation's oracle reverts.
+     */
+    get isLiquidatable(): boolean | undefined;
+    /**
+     * @inheritdoc `undefined` if the pre-liquidation's oracle reverts.
+     */
+    get seizableCollateral(): bigint | undefined;
+}

package/lib/esm/position/PreLiquidationPosition.js

@@ -0,0 +1,97 @@
+import { ORACLE_PRICE_SCALE } from "../constants.js";
+import { Market } from "../market/index.js";
+import { MathLib, SharesMath } from "../math/index.js";
+import { AccrualPosition } from "./Position.js";
+export class PreLiquidationParams {
+    preLltv;
+    preLCF1;
+    preLCF2;
+    preLIF1;
+    preLIF2;
+    preLiquidationOracle;
+    constructor({ preLltv, preLCF1, preLCF2, preLIF1, preLIF2, preLiquidationOracle, }) {
+        this.preLltv = BigInt(preLltv);
+        this.preLCF1 = BigInt(preLCF1);
+        this.preLCF2 = BigInt(preLCF2);
+        this.preLIF1 = BigInt(preLIF1);
+        this.preLIF2 = BigInt(preLIF2);
+        this.preLiquidationOracle = preLiquidationOracle;
+    }
+    getCloseFactor(quotient) {
+        return (this.preLCF1 + MathLib.wMulDown(quotient, this.preLCF2 - this.preLCF1));
+    }
+    getIncentiveFactor(quotient) {
+        return (this.preLIF1 + MathLib.wMulDown(quotient, this.preLIF2 - this.preLIF1));
+    }
+}
+export class PreLiquidationPosition extends AccrualPosition {
+    preLiquidationParams;
+    preLiquidation;
+    preLiquidationOraclePrice;
+    _baseMarket;
+    constructor({ preLiquidationParams, preLiquidation, preLiquidationOraclePrice, ...position }, market) {
+        super(position, {
+            ...market,
+            params: {
+                ...market.params,
+                lltv: BigInt(preLiquidationParams.preLltv),
+            },
+            price: preLiquidationOraclePrice != null
+                ? BigInt(preLiquidationOraclePrice)
+                : undefined,
+        });
+        this.preLiquidationParams = new PreLiquidationParams(preLiquidationParams);
+        this.preLiquidation = preLiquidation;
+        if (preLiquidationOraclePrice != null)
+            this.preLiquidationOraclePrice = BigInt(preLiquidationOraclePrice);
+        this._baseMarket = new Market(market);
+    }
+    get market() {
+        return this._baseMarket;
+    }
+    get _lltv() {
+        return this._baseMarket.params.lltv;
+    }
+    /**
+     * @inheritdoc `undefined` if the pre-liquidation's oracle reverts.
+     * `undefined` if it may be liquidatable on Morpho.
+     */
+    get isHealthy() {
+        const { collateralValue } = this;
+        if (collateralValue == null)
+            return;
+        const { borrowAssets } = this;
+        if (borrowAssets > MathLib.wMulDown(collateralValue, this._lltv))
+            return;
+        return (borrowAssets <=
+            MathLib.wMulDown(collateralValue, this.preLiquidationParams.preLltv));
+    }
+    /**
+     * @inheritdoc `undefined` if the pre-liquidation's oracle reverts.
+     */
+    get isLiquidatable() {
+        const { collateralValue } = this;
+        if (collateralValue == null)
+            return;
+        const { borrowAssets } = this;
+        return (borrowAssets >
+            MathLib.wMulDown(collateralValue, this.preLiquidationParams.preLltv) &&
+            borrowAssets <= MathLib.wMulDown(collateralValue, this._lltv));
+    }
+    /**
+     * @inheritdoc `undefined` if the pre-liquidation's oracle reverts.
+     */
+    get seizableCollateral() {
+        if (this._market.price == null)
+            return;
+        if (!this.isLiquidatable)
+            return 0n;
+        const { ltv } = this;
+        if (ltv == null)
+            return;
+        const quotient = MathLib.wDivDown(ltv - this.preLiquidationParams.preLltv, this._lltv - this.preLiquidationParams.preLltv);
+        const repayableShares = MathLib.wMulDown(this.borrowShares, this.preLiquidationParams.getCloseFactor(quotient));
+        const repayableAssets = MathLib.wMulDown(SharesMath.toAssets(repayableShares, this._market.totalBorrowAssets, this._market.totalBorrowShares, "Down"), this.preLiquidationParams.getIncentiveFactor(quotient));
+        return MathLib.mulDivDown(repayableAssets, ORACLE_PRICE_SCALE, this._market.price);
+    }
+}

package/lib/esm/position/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Position.js";
+export * from "./PreLiquidationPosition.js";

package/lib/esm/position/index.js

@@ -0,0 +1,2 @@
+export * from "./Position.js";
+export * from "./PreLiquidationPosition.js";

package/lib/esm/preLiquidation.d.ts

@@ -0,0 +1,15 @@
+import type { BigIntish } from "./types.js";
+export declare const defaultPreLiquidationParamsRegistry: Map<bigint, {
+    preLltv: bigint;
+    preLCF1: bigint;
+    preLCF2: bigint;
+    preLIF1: bigint;
+    preLIF2: bigint;
+}>;
+export declare const getDefaultPreLiquidationParams: (lltv: BigIntish) => {
+    preLltv: bigint;
+    preLCF1: bigint;
+    preLCF2: bigint;
+    preLIF1: bigint;
+    preLIF2: bigint;
+};

package/lib/esm/preLiquidation.js

@@ -0,0 +1,91 @@
+import { parseEther } from "viem";
+import { UnsupportedPreLiquidationParamsError } from "./errors.js";
+export const defaultPreLiquidationParamsRegistry = new Map([
+    [
+        parseEther("0.385"),
+        {
+            preLltv: 301514568055515563n,
+            preLCF1: 22637943984157107n,
+            preLCF2: 349673199983645648n,
+            preLIF1: parseEther("1.15"),
+            preLIF2: parseEther("1.15"),
+        },
+    ],
+    [
+        parseEther("0.625"),
+        {
+            preLltv: 562591950487445723n,
+            preLCF1: 7543182567291709n,
+            preLCF2: 279542312587328718n,
+            preLIF1: 1126760563380281690n,
+            preLIF2: 1126760563380281690n,
+        },
+    ],
+    [
+        parseEther("0.77"),
+        {
+            preLltv: 727366070175296029n,
+            preLCF1: 3706417131700377n,
+            preLCF2: 256643181309902852n,
+            preLIF1: 1074113856068743286n,
+            preLIF2: 1074113856068743286n,
+        },
+    ],
+    [
+        parseEther("0.86"),
+        {
+            preLltv: 832603694978499652n,
+            preLCF1: 2001493508968667n,
+            preLCF2: 245311807032632372n,
+            preLIF1: 1043841336116910229n,
+            preLIF2: 1043841336116910229n,
+        },
+    ],
+    [
+        parseEther("0.915"),
+        {
+            preLltv: 897868776651447149n,
+            preLCF1: 1135586186384195n,
+            preLCF2: 239205538157954887n,
+            preLIF1: 1026167265264238070n,
+            preLIF2: 1026167265264238070n,
+        },
+    ],
+    [
+        parseEther("0.945"),
+        {
+            preLltv: 933746617913300027n,
+            preLCF1: 709220796660800n,
+            preLCF2: 236098907251355946n,
+            preLIF1: 1016776817488561260n,
+            preLIF2: 1016776817488561260n,
+        },
+    ],
+    [
+        parseEther("0.965"),
+        {
+            preLltv: 957768981497388846n,
+            preLCF1: 441038514876104n,
+            preLCF2: 234108264807531861n,
+            preLIF1: 1010611419909044972n,
+            preLIF2: 1010611419909044972n,
+        },
+    ],
+    [
+        parseEther("0.98"),
+        {
+            preLltv: 975838577830248552n,
+            preLCF1: 247773050273784n,
+            preLCF2: 232655340599010079n,
+            preLIF1: 1006036217303822937n,
+            preLIF2: 1006036217303822937n,
+        },
+    ],
+]);
+export const getDefaultPreLiquidationParams = (lltv) => {
+    lltv = BigInt(lltv);
+    const defaultParams = defaultPreLiquidationParamsRegistry.get(lltv);
+    if (defaultParams == null)
+        throw new UnsupportedPreLiquidationParamsError(lltv);
+    return defaultParams;
+};

package/lib/esm/token/ConstantWrappedToken.d.ts

@@ -0,0 +1,17 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { Address, BigIntish } from "../types.js";
+import type { IToken } from "./Token.js";
+import { WrappedToken } from "./WrappedToken.js";
+export declare class ConstantWrappedToken extends WrappedToken {
+    readonly underlyingDecimals: bigint;
+    constructor(token: IToken, underlying: Address, underlyingDecimals?: BigIntish);
+    toWrappedExactAmountIn(unwrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    protected _wrap(amount: bigint): bigint;
+    protected _unwrap(amount: bigint): bigint;
+}

package/lib/esm/token/ConstantWrappedToken.js

@@ -0,0 +1,30 @@
+import { MathLib } from "../math/index.js";
+import { WrappedToken } from "./WrappedToken.js";
+export class ConstantWrappedToken extends WrappedToken {
+    underlyingDecimals;
+    constructor(token, underlying, underlyingDecimals = 0) {
+        super(token, underlying);
+        this.underlyingDecimals = BigInt(underlyingDecimals);
+    }
+    toWrappedExactAmountIn(unwrappedAmount, _slippage, rounding = "Down") {
+        return super.toWrappedExactAmountIn(unwrappedAmount, 0n, rounding);
+    }
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount, _slippage, rounding = "Up") {
+        return super.toWrappedExactAmountOut(wrappedAmount, 0n, rounding);
+    }
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount, _slippage, rounding = "Down") {
+        return super.toUnwrappedExactAmountIn(wrappedAmount, 0n, rounding);
+    }
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount, _slippage, rounding = "Up") {
+        return super.toUnwrappedExactAmountOut(unwrappedAmount, 0n, rounding);
+    }
+    _wrap(amount) {
+        return MathLib.mulDivDown(amount, 10n ** BigInt(this.decimals), 10n ** this.underlyingDecimals);
+    }
+    _unwrap(amount) {
+        return MathLib.mulDivDown(amount, 10n ** this.underlyingDecimals, 10n ** BigInt(this.decimals));
+    }
+}

package/lib/esm/token/Eip5267Domain.d.ts

@@ -0,0 +1,55 @@
+import type { Address } from "../types.js";
+export declare const EIP_712_FIELDS: readonly ["name", "version", "chainId", "verifyingContract", "salt"];
+export type Eip712Field = (typeof EIP_712_FIELDS)[number];
+export interface IEip5267Domain {
+    fields: `0x${string}`;
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: Address;
+    salt: `0x${string}`;
+    extensions: readonly bigint[];
+}
+export declare class Eip5267Domain implements IEip5267Domain {
+    /**
+     * A bit map where bit i is set to 1 if and only if domain field i is present (0 ≤ i ≤ 4).
+     * Bits are read from least significant to most significant, and fields are indexed in the order that is specified by EIP-712, identical to the order in which they are listed in the function type.
+     */
+    readonly fields: `0x${string}`;
+    /**
+     * The user readable name of signing domain, i.e. the name of the DApp or the protocol.
+     */
+    readonly name: string;
+    /**
+     * The current major version of the signing domain.
+     * Signatures from different versions are not compatible.
+     */
+    readonly version: string;
+    /**
+     * The EIP-155 chain id.
+     */
+    readonly chainId: bigint;
+    /**
+     * The address of the contract that will verify the EIP-712 signature.
+     */
+    readonly verifyingContract: `0x${string}`;
+    /**
+     * A disambiguating salt for the protocol.
+     * This can be used as a domain separator of last resort.
+     */
+    readonly salt: `0x${string}`;
+    /**
+     * A list of EIP numbers, each of which MUST refer to an EIP that extends EIP-712 with new domain fields, along with a method to obtain the value for those fields, and potentially conditions for inclusion.
+     * The value of fields does not affect their inclusion.
+     */
+    readonly extensions: readonly bigint[];
+    readonly eip712Domain: {
+        name?: string | undefined;
+        chainId?: number | undefined;
+        version?: string | undefined;
+        verifyingContract?: `0x${string}` | undefined;
+        salt?: `0x${string}` | undefined;
+    };
+    constructor({ fields, name, version, chainId, verifyingContract, salt, extensions, }: IEip5267Domain);
+    private asEip712Domain;
+}

package/lib/esm/token/Eip5267Domain.js

@@ -0,0 +1,66 @@
+export const EIP_712_FIELDS = [
+    "name",
+    "version",
+    "chainId",
+    "verifyingContract",
+    "salt",
+];
+export class Eip5267Domain {
+    /**
+     * A bit map where bit i is set to 1 if and only if domain field i is present (0 ≤ i ≤ 4).
+     * Bits are read from least significant to most significant, and fields are indexed in the order that is specified by EIP-712, identical to the order in which they are listed in the function type.
+     */
+    fields;
+    /**
+     * The user readable name of signing domain, i.e. the name of the DApp or the protocol.
+     */
+    name;
+    /**
+     * The current major version of the signing domain.
+     * Signatures from different versions are not compatible.
+     */
+    version;
+    /**
+     * The EIP-155 chain id.
+     */
+    chainId;
+    /**
+     * The address of the contract that will verify the EIP-712 signature.
+     */
+    verifyingContract;
+    /**
+     * A disambiguating salt for the protocol.
+     * This can be used as a domain separator of last resort.
+     */
+    salt;
+    /**
+     * A list of EIP numbers, each of which MUST refer to an EIP that extends EIP-712 with new domain fields, along with a method to obtain the value for those fields, and potentially conditions for inclusion.
+     * The value of fields does not affect their inclusion.
+     */
+    extensions;
+    eip712Domain;
+    constructor({ fields, name, version, chainId, verifyingContract, salt, extensions, }) {
+        this.fields = fields;
+        this.name = name;
+        this.version = version;
+        this.chainId = chainId;
+        this.verifyingContract = verifyingContract;
+        this.salt = salt;
+        this.extensions = extensions;
+        this.eip712Domain = this.asEip712Domain();
+    }
+    asEip712Domain() {
+        const fields = BigInt(this.fields);
+        return EIP_712_FIELDS.reduce((acc, field, i) => {
+            if (fields & (2n ** BigInt(i))) {
+                // @ts-expect-error Typescript doesn't infer value type based on field.
+                acc[field] =
+                    field === "chainId"
+                        ? // Signature does not correspond if chainId is a bigint.
+                            Number(this.chainId)
+                        : this[field];
+            }
+            return acc;
+        }, {});
+    }
+}