@morpho-org/blue-sdk 2.0.0-next.1 → 2.0.0-next.2

package/lib/chain.js

@@ -0,0 +1,286 @@
+import { UnsupportedChainIdError } from "./errors.js";
+export var ChainId;
+(function (ChainId) {
+    ChainId[ChainId["EthMainnet"] = 1] = "EthMainnet";
+    ChainId[ChainId["BaseMainnet"] = 8453] = "BaseMainnet";
+    // EthGoerliTestnet = 5,
+    // PolygonMainnet = 137,
+    // MumbaiTestnet = 80001,
+    // OptimismMainnet = 10,
+    // BscMainnet = 56,
+    // ArbitrumMainnet = 42161,
+    // ArbitrumTestnet = 421611,
+    // GnosisChain = 100,
+    // FantomMainnet = 250,
+    // FantomTestnet = 4002,
+    // HarmonyMainnet = 128,
+    // HarmonyTestnet = 1666600000,
+    // BscTestnet = 97,
+    // OptimismTestnet = 69,
+    // EthRopstenTestnet = 3,
+    // EthRinkebyTestnet = 4,
+    // EthKovanTestnet = 42,
+    // GnosisChainTestnet = 10200,
+    // AvalancheMainnet = 43114,
+    // AvalancheFujiTestnet = 43113,
+    // MoonbaseAlphaTestnet = 1287,
+    // BaseGoerliTestnet = 84531,
+})(ChainId || (ChainId = {}));
+export var ChainUtils;
+(function (ChainUtils) {
+    ChainUtils.toHexChainId = (chainId) => {
+        return `0x${chainId.toString(16)}`;
+    };
+    ChainUtils.getExplorerUrl = (chainId) => {
+        return ChainUtils.CHAIN_METADATA[chainId].explorerUrl;
+    };
+    ChainUtils.getExplorerAddressUrl = (chainId, address) => {
+        return `${ChainUtils.getExplorerUrl(chainId)}/address/${address}`;
+    };
+    ChainUtils.getExplorerTransactionUrl = (chainId, tx) => {
+        return `${ChainUtils.getExplorerUrl(chainId)}/tx/${tx}`;
+    };
+    function isSupported(chainId) {
+        return ChainUtils.BLUE_AVAILABLE_CHAINS.includes(chainId);
+    }
+    ChainUtils.isSupported = isSupported;
+    function parseSupportedChainId(candidate) {
+        const chainId = Number.parseInt(candidate); // Force cast to string to silence TS because it works.
+        if (!isSupported(chainId))
+            throw new UnsupportedChainIdError(chainId);
+        return chainId;
+    }
+    ChainUtils.parseSupportedChainId = parseSupportedChainId;
+    ChainUtils.BLUE_AVAILABLE_CHAINS = [
+        ChainId.EthMainnet,
+        ChainId.BaseMainnet,
+    ];
+    ChainUtils.CHAIN_METADATA = {
+        [ChainId.EthMainnet]: {
+            name: "Ethereum",
+            id: ChainId.EthMainnet,
+            nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+            defaultRpcUrl: "https://mainnet.infura.io/V3/84842078b09946638c03157f83405213",
+            explorerUrl: "https://etherscan.io",
+            isTestnet: false,
+            shortName: "ETH",
+            logoSrc: "https://cdn.morpho.org/assets/chains/eth.svg",
+            identifier: "mainnet",
+        },
+        [ChainId.BaseMainnet]: {
+            name: "Base",
+            id: ChainId.BaseMainnet,
+            nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+            defaultRpcUrl: "https://rpc.baseprotocol.org",
+            explorerUrl: "https://basescan.org",
+            isTestnet: false,
+            shortName: "Base",
+            logoSrc: "https://cdn.morpho.org/assets/chains/base.png",
+            identifier: "base",
+        },
+        // [ChainId.EthGoerliTestnet]: {
+        //   name: "Ethereum Goerli Testnet",
+        //   id: ChainId.EthGoerliTestnet,
+        //   nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
+        //   defaultRpcUrl:
+        //     "https://goerli.infura.io/V3/84842078b09946638c03157f83405213",
+        //   explorerUrl: "https://goerli.etherscan.io",
+        //   isTestnet: true,
+        //   shortName: "Goerli",
+        //   logoSrc: "https://cdn.morpho.org/assets/chains/eth.svg",
+        //   identifier: "goerli",
+        // },
+        // [ChainId.PolygonMainnet]: {
+        //   name: "Polygon Mainnet",
+        //   id: ChainId.PolygonMainnet,
+        //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+        //   defaultRpcUrl: "https://rpc-mainnet.maticvigil.com",
+        //   explorerUrl: "https://polygonscan.com",
+        //   isTestnet: false,
+        //   shortName: "Polygon",
+        // },
+        // [ChainId.MumbaiTestnet]: {
+        //   name: "Mumbai Testnet",
+        //   id: ChainId.MumbaiTestnet,
+        //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+        //   defaultRpcUrl: "https://rpc-mumbai.maticvigil.com",
+        //   explorerUrl: "https://mumbai.polygonscan.com",
+        //   isTestnet: true,
+        //   shortName: "Mumbai",
+        // },
+        /* see https://chainid.network/chains.json */
+        // [ChainId.PolygonMainnet]: {
+        //   name: "Polygon Mainnet",
+        //   id: ChainId.PolygonMainnet,
+        //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+        //   defaultRpcUrl: "https://rpc-mainnet.maticvigil.com",
+        //   explorerUrl: "https://polygonscan.com",
+        //   isTestnet: false,
+        //   shortName: "Polygon",
+        // },
+        // [ChainId.MumbaiTestnet]: {
+        //   name: "Mumbai Testnet",
+        //   id: ChainId.MumbaiTestnet,
+        //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+        //   defaultRpcUrl: "https://rpc-mumbai.maticvigil.com",
+        //   explorerUrl: "https://mumbai.polygonscan.com",
+        //   isTestnet: true,
+        //   shortName: "Mumbai",
+        // },
+        // [ChainId.OptimismMainnet]: {
+        //   name: "Optimism Mainnet",
+        //   id: ChainId.OptimismMainnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl: "https://mainnet.optimism.io",
+        //   explorerUrl: "https://optimistic.etherscan.io",
+        //   isTestnet: false,
+        // },
+        // [ChainId.BscMainnet]: {
+        //   name: "Binance Smart Chain Mainnet",
+        //   id: ChainId.BscMainnet,
+        //   baseCurrency: "BNB",
+        //   defaultRpcUrl: "https://bsc-dataseed.binance.org",
+        //   explorerUrl: "https://bscscan.com",
+        //   isTestnet: false,
+        // },
+        // [ChainId.ArbitrumMainnet]: {
+        //   name: "Arbitrum Mainnet",
+        //   id: ChainId.ArbitrumMainnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl: "https://arb1.arbitrum.io/rpc",
+        //   explorerUrl: "https://arbiscan.io",
+        //   isTestnet: false,
+        // },
+        // [ChainId.ArbitrumTestnet]: {
+        //   name: "Arbitrum Testnet",
+        //   id: ChainId.ArbitrumTestnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl: "https://rinkeby.arbitrum.io/rpc",
+        //   explorerUrl: "https://rinkeby-explorer.arbitrum.io",
+        //   isTestnet: true,
+        // },
+        // [ChainId.GnosisChain]: {
+        //   name: "Gnosis Chain",
+        //   id: ChainId.GnosisChain,
+        //   baseCurrency: "XDAI",
+        //   defaultRpcUrl: "https://rpc.xdaichain.com",
+        //   explorerUrl: "https://gnosis.blockscout.com",
+        //   isTestnet: false,
+        // },
+        // [ChainId.FantomMainnet]: {
+        //   name: "Fantom Mainnet",
+        //   id: ChainId.FantomMainnet,
+        //   baseCurrency: "FTM",
+        //   defaultRpcUrl: "https://rpcapi.fantom.network",
+        //   explorerUrl: "https://ftmscan.com",
+        //   isTestnet: false,
+        // },
+        // [ChainId.FantomTestnet]: {
+        //   name: "Fantom Testnet",
+        //   id: ChainId.FantomTestnet,
+        //   baseCurrency: "FTM",
+        //   defaultRpcUrl: "https://rpc.testnet.fantom.network",
+        //   explorerUrl: "https://explorer.testnet.fantom.network",
+        //   isTestnet: true,
+        // },
+        // [ChainId.HarmonyMainnet]: {
+        //   name: "Harmony Mainnet",
+        //   id: ChainId.HarmonyMainnet,
+        //   baseCurrency: "ONE",
+        //   defaultRpcUrl: "https://api.harmony.one",
+        //   explorerUrl: "https://explorer.harmony.one",
+        //   isTestnet: false,
+        // },
+        // [ChainId.HarmonyTestnet]: {
+        //   name: "Harmony Testnet",
+        //   id: ChainId.HarmonyTestnet,
+        //   baseCurrency: "ONE",
+        //   defaultRpcUrl: "https://api.s0.b.hmny.io",
+        //   explorerUrl: "https://explorer.testnet.harmony.one",
+        //   isTestnet: true,
+        // },
+        // [ChainId.BscTestnet]: {
+        //   name: "Binance Smart Chain Testnet",
+        //   id: ChainId.BscTestnet,
+        //   baseCurrency: "BNB",
+        //   defaultRpcUrl: "https://data-seed-prebsc-1-s1.binance.org:8545",
+        //   explorerUrl: "https://testnet.bscscan.com",
+        //   isTestnet: true,
+        // },
+        // [ChainId.OptimismTestnet]: {
+        //   name: "Optimism Testnet",
+        //   id: ChainId.OptimismTestnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl: "https://kovan.optimism.io",
+        //   explorerUrl: "https://kovan-optimistic.etherscan.io",
+        //   isTestnet: true,
+        // },
+        // [ChainId.EthRopstenTestnet]: {
+        //   name: "Ethereum Ropsten Testnet",
+        //   id: ChainId.EthRopstenTestnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl:
+        //     "https://ropsten.infura.io/V4/84842078b09946638c03157f83405213",
+        //   explorerUrl: "https://ropsten.etherscan.io",
+        //   isTestnet: true,
+        // },
+        // [ChainId.EthRinkebyTestnet]: {
+        //   name: "Ethereum Rinkeby Testnet",
+        //   id: ChainId.EthRinkebyTestnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl:
+        //     "https://rinkeby.infura.io/V4/84842078b09946638c03157f83405213",
+        //   explorerUrl: "https://rinkeby.etherscan.io",
+        //   isTestnet: true,
+        // },
+        // [ChainId.EthKovanTestnet]: {
+        //   name: "Ethereum Kovan Testnet",
+        //   id: ChainId.EthKovanTestnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl:
+        //     "https://kovan.infura.io/V4/84842078b09946638c03157f83405213",
+        //   explorerUrl: "https://kovan.etherscan.io",
+        //   isTestnet: true,
+        // },
+        // [ChainId.BaseGoerliTestnet]: {
+        //   name: "Base Goerli Testnet",
+        //   id: ChainId.BaseGoerliTestnet,
+        //   baseCurrency: "ETH",
+        //   defaultRpcUrl: "https://rpc-goerli.baseprotocol.org",
+        //   explorerUrl: "https://goerli.basescan.org",
+        //   isTestnet: true,
+        // },
+        // [ChainId.GnosisChainTestnet]: {
+        //   name: "Gnosis Chain Testnet",
+        //   id: ChainId.GnosisChainTestnet,
+        //   baseCurrency: "XDAI",
+        //   defaultRpcUrl: "https://rpc.chiado.gnosis.gateway.fm",
+        //   explorerUrl: "https://gnosis-chiado.blockscout.com/",
+        //   isTestnet: true,
+        // },
+        // [ChainId.AvalancheMainnet]: {
+        //   name: "Avalanche Mainnet",
+        //   id: ChainId.AvalancheMainnet,
+        //   baseCurrency: "AVAX",
+        //   defaultRpcUrl: "https://api.avax.network/ext/bc/C/rpc",
+        //   explorerUrl: "https://cchain.explorer.avax.network",
+        //   isTestnet: false,
+        // },
+        // [ChainId.AvalancheFujiTestnet]: {
+        //   name: "Avalanche Fuji Testnet",
+        //   id: ChainId.AvalancheFujiTestnet,
+        //   baseCurrency: "AVAX",
+        //   defaultRpcUrl: "https://api.avax-test.network/ext/bc/C/rpc",
+        //   explorerUrl: "https://cchain.explorer.avax-test.network",
+        //   isTestnet: true,
+        // },
+        // [ChainId.MoonbaseAlphaTestnet]: {
+        //   name: "Moonbase Alpha Testnet",
+        //   id: ChainId.MoonbaseAlphaTestnet,
+        //   baseCurrency: "DEV",
+        //   defaultRpcUrl: "https://rpc.testnet.moonbeam.network",
+        //   explorerUrl: "https://moonbase-blockscout.testnet.moonbeam.network",
+        //   isTestnet: true,
+        // },
+    };
+})(ChainUtils || (ChainUtils = {}));

package/lib/constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The liquidation cursor used to calculate the liquidation incentive. Hardcoded to 30%.
+ */
+export declare const LIQUIDATION_CURSOR = 300000000000000000n;
+/**
+ * The maximum liquidation incentive factor. Hardcoded to 115%.
+ */
+export declare const MAX_LIQUIDATION_INCENTIVE_FACTOR = 1150000000000000000n;
+export declare const ORACLE_PRICE_OFFSET = 36;
+/**
+ * The scale of the oracle price. Hardcoded to 1e36.
+ */
+export declare const ORACLE_PRICE_SCALE = 1000000000000000000000000000000000000n;
+/**
+ * The default slippage tolerance used in the SDK. Hardcoded to 0.03%.
+ */
+export declare const DEFAULT_SLIPPAGE_TOLERANCE = 300000000000000n;
+/**
+ * The default withdrawal target utilization used by the shared liquidity algorithm. Hardcoded to 92%.
+ */
+export declare const DEFAULT_WITHDRAWAL_TARGET_UTILIZATION = 920000000000000000n;
+/**
+ * The default supply target utilization used by the shared liquidity algorithm. Hardcoded to 90.5%.
+ */
+export declare const DEFAULT_SUPPLY_TARGET_UTILIZATION = 905000000000000000n;
+/**
+ * The number of seconds in a year.
+ */
+export declare const SECONDS_PER_YEAR: bigint;

package/lib/constants.js

@@ -0,0 +1,30 @@
+import { Time } from "@morpho-org/morpho-ts";
+/**
+ * The liquidation cursor used to calculate the liquidation incentive. Hardcoded to 30%.
+ */
+export const LIQUIDATION_CURSOR = 300000000000000000n;
+/**
+ * The maximum liquidation incentive factor. Hardcoded to 115%.
+ */
+export const MAX_LIQUIDATION_INCENTIVE_FACTOR = 1150000000000000000n;
+export const ORACLE_PRICE_OFFSET = 36;
+/**
+ * The scale of the oracle price. Hardcoded to 1e36.
+ */
+export const ORACLE_PRICE_SCALE = 1000000000000000000000000000000000000n;
+/**
+ * The default slippage tolerance used in the SDK. Hardcoded to 0.03%.
+ */
+export const DEFAULT_SLIPPAGE_TOLERANCE = 300000000000000n;
+/**
+ * The default withdrawal target utilization used by the shared liquidity algorithm. Hardcoded to 92%.
+ */
+export const DEFAULT_WITHDRAWAL_TARGET_UTILIZATION = 920000000000000000n;
+/**
+ * The default supply target utilization used by the shared liquidity algorithm. Hardcoded to 90.5%.
+ */
+export const DEFAULT_SUPPLY_TARGET_UTILIZATION = 905000000000000000n;
+/**
+ * The number of seconds in a year.
+ */
+export const SECONDS_PER_YEAR = Time.s.from.y(1n);

package/lib/errors.d.ts

@@ -0,0 +1,52 @@
+import type { Address, MarketId } from "./types.js";
+export declare class UnknownDataError extends Error {
+}
+export declare class UnknownTokenError extends UnknownDataError {
+    readonly address: Address;
+    constructor(address: Address);
+}
+export declare class UnknownTokenPriceError extends UnknownDataError {
+    readonly address: Address;
+    constructor(address: Address);
+}
+export declare class UnknownMarketConfigError extends UnknownDataError {
+    readonly marketId: MarketId;
+    constructor(marketId: MarketId);
+}
+export declare class UnknownVaultConfigError extends UnknownDataError {
+    readonly vault: Address;
+    constructor(vault: Address);
+}
+export declare class UnsupportedChainIdError extends Error {
+    readonly chainId: number;
+    constructor(chainId: number);
+}
+export declare namespace BlueErrors {
+    class InvalidInterestAccrual extends Error {
+        readonly marketId: MarketId;
+        readonly timestamp: bigint;
+        readonly lastUpdate: bigint;
+        constructor(marketId: MarketId, timestamp: bigint, lastUpdate: bigint);
+    }
+    class InconsistentInput extends Error {
+        constructor();
+    }
+    class InsufficientLiquidity extends Error {
+        readonly marketId: MarketId;
+        constructor(marketId: MarketId);
+    }
+    class InsufficientPosition extends Error {
+        readonly user: Address;
+        readonly marketId: MarketId;
+        constructor(user: Address, marketId: MarketId);
+    }
+    class InsufficientCollateral extends Error {
+        readonly user: Address;
+        readonly marketId: MarketId;
+        constructor(user: Address, marketId: MarketId);
+    }
+}
+export interface ErrorClass<E extends Error> {
+    new (...args: any[]): E;
+}
+export declare function _try<T, E extends Error>(accessor: () => T, ...errorClasses: ErrorClass<E>[]): T | undefined;

package/lib/errors.js

@@ -0,0 +1,97 @@
+export class UnknownDataError extends Error {
+}
+export class UnknownTokenError extends UnknownDataError {
+    address;
+    constructor(address) {
+        super(`unknown token ${address}`);
+        this.address = address;
+    }
+}
+export class UnknownTokenPriceError extends UnknownDataError {
+    address;
+    constructor(address) {
+        super(`unknown price of token ${address}`);
+        this.address = address;
+    }
+}
+export class UnknownMarketConfigError extends UnknownDataError {
+    marketId;
+    constructor(marketId) {
+        super(`unknown config for market ${marketId}`);
+        this.marketId = marketId;
+    }
+}
+export class UnknownVaultConfigError extends UnknownDataError {
+    vault;
+    constructor(vault) {
+        super(`unknown config for vault ${vault}`);
+        this.vault = vault;
+    }
+}
+export class UnsupportedChainIdError extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`unsupported chain ${chainId}`);
+        this.chainId = chainId;
+    }
+}
+export var BlueErrors;
+(function (BlueErrors) {
+    class InvalidInterestAccrual extends Error {
+        marketId;
+        timestamp;
+        lastUpdate;
+        constructor(marketId, timestamp, lastUpdate) {
+            super(`invalid interest accrual on market ${marketId}: accrual timestamp ${timestamp} can't be prior to last update ${lastUpdate}`);
+            this.marketId = marketId;
+            this.timestamp = timestamp;
+            this.lastUpdate = lastUpdate;
+        }
+    }
+    BlueErrors.InvalidInterestAccrual = InvalidInterestAccrual;
+    class InconsistentInput extends Error {
+        constructor() {
+            super(`inconsistent input: assets & shares cannot both be zero`);
+        }
+    }
+    BlueErrors.InconsistentInput = InconsistentInput;
+    class InsufficientLiquidity extends Error {
+        marketId;
+        constructor(marketId) {
+            super(`insufficient liquidity on market ${marketId}`);
+            this.marketId = marketId;
+        }
+    }
+    BlueErrors.InsufficientLiquidity = InsufficientLiquidity;
+    class InsufficientPosition extends Error {
+        user;
+        marketId;
+        constructor(user, marketId) {
+            super(`insufficient position for user ${user} on market ${marketId}`);
+            this.user = user;
+            this.marketId = marketId;
+        }
+    }
+    BlueErrors.InsufficientPosition = InsufficientPosition;
+    class InsufficientCollateral extends Error {
+        user;
+        marketId;
+        constructor(user, marketId) {
+            super(`insufficient collateral for user ${user} on market ${marketId}`);
+            this.user = user;
+            this.marketId = marketId;
+        }
+    }
+    BlueErrors.InsufficientCollateral = InsufficientCollateral;
+})(BlueErrors || (BlueErrors = {}));
+export function _try(accessor, ...errorClasses) {
+    try {
+        return accessor();
+    }
+    catch (error) {
+        if (errorClasses.length === 0 ||
+            errorClasses.some((errorClass) => error instanceof errorClass))
+            return;
+        throw error;
+    }
+}

package/lib/holding/AssetBalances.d.ts

@@ -0,0 +1,48 @@
+import type { Token } from "../token/Token.js";
+export type PeripheralBalanceType = "base" | "wrapped" | "staked-wrapped" | "vault" | "wrapped-vault" | "unwrapped-staked-wrapped";
+/**
+ * Represents the balance of a requested token and the balance quoted in the corresponding source token:
+ * ```{
+ *  type: "staked-wrapped",
+ *  srcToken: ETH,
+ *  srcAmount: 1 ETH,
+ *  dstAmount: 1.2 wstETH
+ * }```
+ */
+export interface PeripheralBalance {
+    /**
+     * The type of balance conversion.
+     */
+    type: PeripheralBalanceType;
+    /**
+     * The source token held corresponding to the type of balance conversion.
+     */
+    srcToken: Token;
+    /**
+     * The source amount of source token held.
+     */
+    srcAmount: bigint;
+    /**
+     * The corresponding amount of token held after conversion of the whole balance `srcAmount`.
+     */
+    dstAmount: bigint;
+}
+export interface InputAssetBalances extends Omit<PeripheralBalance, "type"> {
+}
+export declare class AssetBalances {
+    /**
+     * The total balance of all types of related tokens.
+     */
+    total: bigint;
+    /**
+     * The balance of each type of related tokens and the corresponding underlying balance.
+     */
+    allocations: {
+        base: PeripheralBalance;
+    } & {
+        [T in Exclude<PeripheralBalanceType, "base">]?: PeripheralBalance;
+    };
+    constructor(balance: InputAssetBalances);
+    add(balance: PeripheralBalance): this;
+    sub(balance: PeripheralBalance): this;
+}

package/lib/holding/AssetBalances.js

@@ -0,0 +1,38 @@
+export class AssetBalances {
+    /**
+     * The total balance of all types of related tokens.
+     */
+    total;
+    /**
+     * The balance of each type of related tokens and the corresponding underlying balance.
+     */
+    allocations;
+    constructor(balance) {
+        this.total = balance.dstAmount;
+        this.allocations = {
+            base: { ...balance, type: "base" },
+        };
+    }
+    add(balance) {
+        this.total += balance.dstAmount;
+        const allocation = (this.allocations[balance.type] ??= {
+            ...balance,
+            srcAmount: 0n,
+            dstAmount: 0n,
+        });
+        allocation.srcAmount += balance.srcAmount;
+        allocation.dstAmount += balance.dstAmount;
+        return this;
+    }
+    sub(balance) {
+        this.total -= balance.dstAmount;
+        const allocation = (this.allocations[balance.type] ??= {
+            ...balance,
+            srcAmount: 0n,
+            dstAmount: 0n,
+        });
+        allocation.srcAmount -= balance.srcAmount;
+        allocation.dstAmount -= balance.dstAmount;
+        return this;
+    }
+}

package/lib/holding/Holding.d.ts

@@ -0,0 +1,64 @@
+import type { Address, BigIntish } from "../types.js";
+export declare const ERC20_ALLOWANCE_RECIPIENTS: readonly ["morpho", "permit2", "bundler"];
+export declare const PERMIT2_ALLOWANCE_RECIPIENTS: readonly ["morpho", "bundler"];
+export type Erc20AllowanceRecipient = (typeof ERC20_ALLOWANCE_RECIPIENTS)[number];
+export type Permit2AllowanceRecipient = (typeof PERMIT2_ALLOWANCE_RECIPIENTS)[number];
+export interface Permit2Allowance {
+    amount: bigint;
+    expiration: bigint;
+    nonce: bigint;
+}
+export interface InputPermit2Allowance {
+    amount: BigIntish;
+    expiration: BigIntish;
+    nonce: BigIntish;
+}
+export interface InputHolding {
+    user: Address;
+    token: Address;
+    erc20Allowances: {
+        [key in Erc20AllowanceRecipient]: bigint;
+    };
+    permit2Allowances: {
+        [key in Permit2AllowanceRecipient]: InputPermit2Allowance;
+    };
+    erc2612Nonce?: bigint;
+    canTransfer?: boolean;
+    balance: bigint;
+}
+export declare class Holding implements InputHolding {
+    /**
+     * The user of this holding.
+     */
+    readonly user: Address;
+    /**
+     * The token in which this holding is denominated.
+     */
+    readonly token: Address;
+    /**
+     * The balance of the user for this token.
+     */
+    balance: bigint;
+    /**
+     * Whether the user is allowed to transfer this holding's balance.
+     */
+    canTransfer?: boolean;
+    /**
+     * ERC20 allowance for this token from the user to the allowance recipient.
+     */
+    readonly erc20Allowances: {
+        [key in Erc20AllowanceRecipient]: bigint;
+    };
+    /**
+     * Permit2 allowance for this token from the user to the allowance recipient.
+     */
+    readonly permit2Allowances: {
+        [key in Permit2AllowanceRecipient]: Permit2Allowance;
+    };
+    /**
+     * ERC-2612 Permit nonce of the user for this token.
+     * `undefined` if the token does not support ERC-2612.
+     */
+    erc2612Nonce?: bigint;
+    constructor({ user, token, erc20Allowances, permit2Allowances, balance, erc2612Nonce, canTransfer, }: InputHolding);
+}