@morpho-org/blue-sdk 1.0.0-integ-650.0

package/lib/chain.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainUtils = exports.ChainId = void 0;
+const errors_1 = require("./errors");
+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 || (exports.ChainId = ChainId = {}));
+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 = parseInt(candidate);
+        if (!isSupported(chainId))
+            throw new errors_1.UnsupportedChainIdError(candidate);
+        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 || (exports.ChainUtils = ChainUtils = {}));

package/lib/chain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/chain.test.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const chain_1 = require("./chain");
+describe("Network", () => {
+    it("Should have consistent chainIds", () => {
+        (0, morpho_ts_1.entries)(chain_1.ChainUtils.CHAIN_METADATA).forEach(([chainId, { id }]) => {
+            expect(+chainId).toEqual(id);
+        });
+    });
+    it("Should have Testnet in the name for testnet chains", () => {
+        Object.values(chain_1.ChainUtils.CHAIN_METADATA)
+            .filter(({ isTestnet }) => isTestnet)
+            .forEach(({ name }) => {
+            expect(name).toMatch(/Testnet/);
+        });
+    });
+    it("Should convert correctly a chainId to hexChainId", () => {
+        expect(chain_1.ChainUtils.toHexChainId(chain_1.ChainId.BaseMainnet)).toEqual("0x2105");
+    });
+});

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,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECONDS_PER_YEAR = exports.DEFAULT_SUPPLY_TARGET_UTILIZATION = exports.DEFAULT_WITHDRAWAL_TARGET_UTILIZATION = exports.DEFAULT_SLIPPAGE_TOLERANCE = exports.ORACLE_PRICE_SCALE = exports.ORACLE_PRICE_OFFSET = exports.MAX_LIQUIDATION_INCENTIVE_FACTOR = exports.LIQUIDATION_CURSOR = void 0;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+/**
+ * The liquidation cursor used to calculate the liquidation incentive. Hardcoded to 30%.
+ */
+exports.LIQUIDATION_CURSOR = 300000000000000000n;
+/**
+ * The maximum liquidation incentive factor. Hardcoded to 115%.
+ */
+exports.MAX_LIQUIDATION_INCENTIVE_FACTOR = 1150000000000000000n;
+exports.ORACLE_PRICE_OFFSET = 36;
+/**
+ * The scale of the oracle price. Hardcoded to 1e36.
+ */
+exports.ORACLE_PRICE_SCALE = 1000000000000000000000000000000000000n;
+/**
+ * The default slippage tolerance used in the SDK. Hardcoded to 0.03%.
+ */
+exports.DEFAULT_SLIPPAGE_TOLERANCE = 300000000000000n;
+/**
+ * The default withdrawal target utilization used by the shared liquidity algorithm. Hardcoded to 92%.
+ */
+exports.DEFAULT_WITHDRAWAL_TARGET_UTILIZATION = 920000000000000000n;
+/**
+ * The default supply target utilization used by the shared liquidity algorithm. Hardcoded to 90.5%.
+ */
+exports.DEFAULT_SUPPLY_TARGET_UTILIZATION = 905000000000000000n;
+/**
+ * The number of seconds in a year.
+ */
+exports.SECONDS_PER_YEAR = morpho_ts_1.Time.s.from.y(1n);

package/lib/errors.d.ts

@@ -0,0 +1,58 @@
+import { Address, MarketId } from "./types";
+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 declare class InvalidSignatureError extends Error {
+    readonly hash: string;
+    readonly signer: Address;
+    readonly recovered: Address;
+    constructor(hash: string, signer: Address, recovered: Address);
+}
+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,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSignatureError = exports.BlueErrors = exports.UnsupportedChainIdError = exports.UnknownVaultConfigError = exports.UnknownMarketConfigError = exports.UnknownTokenPriceError = exports.UnknownTokenError = exports.UnknownDataError = void 0;
+exports._try = _try;
+class UnknownDataError extends Error {
+}
+exports.UnknownDataError = UnknownDataError;
+class UnknownTokenError extends UnknownDataError {
+    address;
+    constructor(address) {
+        super(`unknown token ${address}`);
+        this.address = address;
+    }
+}
+exports.UnknownTokenError = UnknownTokenError;
+class UnknownTokenPriceError extends UnknownDataError {
+    address;
+    constructor(address) {
+        super(`unknown price of token ${address}`);
+        this.address = address;
+    }
+}
+exports.UnknownTokenPriceError = UnknownTokenPriceError;
+class UnknownMarketConfigError extends UnknownDataError {
+    marketId;
+    constructor(marketId) {
+        super(`unknown config for market ${marketId}`);
+        this.marketId = marketId;
+    }
+}
+exports.UnknownMarketConfigError = UnknownMarketConfigError;
+class UnknownVaultConfigError extends UnknownDataError {
+    vault;
+    constructor(vault) {
+        super(`unknown config for vault ${vault}`);
+        this.vault = vault;
+    }
+}
+exports.UnknownVaultConfigError = UnknownVaultConfigError;
+class UnsupportedChainIdError extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`unsupported chain ${chainId}`);
+        this.chainId = chainId;
+    }
+}
+exports.UnsupportedChainIdError = UnsupportedChainIdError;
+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 || (exports.BlueErrors = BlueErrors = {}));
+class InvalidSignatureError extends Error {
+    hash;
+    signer;
+    recovered;
+    constructor(hash, signer, recovered) {
+        super(`invalid signature for hash ${hash}: expected ${signer}, recovered ${recovered}`);
+        this.hash = hash;
+        this.signer = signer;
+        this.recovered = recovered;
+    }
+}
+exports.InvalidSignatureError = InvalidSignatureError;
+function _try(accessor, ...errorClasses) {
+    try {
+        return accessor();
+    }
+    catch (error) {
+        if (errorClasses.length === 0 ||
+            errorClasses.some((errorClass) => error instanceof errorClass))
+            return;
+        throw error;
+    }
+}

package/lib/helpers/format/format.d.ts

@@ -0,0 +1,122 @@
+declare enum Format {
+    number = "number",
+    commas = "commas",
+    short = "short",
+    hex = "hex",
+    percent = "percent"
+}
+interface BaseFormatOptions {
+    format: Format;
+    digits?: number;
+    removeTrailingZero?: boolean;
+    min?: number;
+    max?: number;
+    sign?: boolean;
+    unit?: string;
+    readable?: boolean;
+    locale?: string;
+}
+interface FormatShortOptions extends BaseFormatOptions {
+    format: Format.short;
+    smallValuesWithCommas?: boolean;
+}
+interface FormatHexOptions {
+    format: Format.hex;
+}
+interface FormatCommasOptions extends BaseFormatOptions {
+    format: Format.commas;
+}
+interface FormatNumberOptions extends BaseFormatOptions {
+    format: Format.number;
+}
+interface FormatPercentOptions extends BaseFormatOptions {
+    format: Format.percent;
+}
+type FormatOptions = FormatHexOptions | FormatShortOptions | FormatNumberOptions | FormatCommasOptions | FormatPercentOptions;
+declare global {
+    interface String {
+        insert(index: number, substr: string, fillWith?: string): string;
+    }
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare abstract class BaseFormatter {
+    protected abstract _options: FormatOptions;
+    constructor();
+    of(value: bigint, decimals: number): string;
+    of(value: number): string;
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare class HexFormatter extends BaseFormatter {
+    protected _options: {
+        format: Format;
+    };
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare abstract class CommonFormatter extends BaseFormatter {
+    protected abstract _options: BaseFormatOptions;
+    digits(_d: number): this;
+    removeTrailingZero(): this;
+    readable(): this;
+    min(_m: number): this;
+    max(_m: number): this;
+    sign(): this;
+    unit(_u: string): this;
+    locale(_l: string): this;
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare class NumberFormatter extends CommonFormatter {
+    protected _options: FormatNumberOptions;
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare class CommasFormatter extends CommonFormatter {
+    protected _options: FormatCommasOptions;
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare class ShortFormatter extends CommonFormatter {
+    protected _options: FormatShortOptions;
+    smallValuesWithCommas(): this;
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare class PercentFormatter extends CommonFormatter {
+    protected _options: FormatPercentOptions;
+}
+/**
+ * @deprecated Import from `@morpho-org/morpho-ts`
+ */
+export declare const format: {
+    /**
+     * Return the value as an integer in hex format
+     */
+    readonly hex: HexFormatter;
+    /**
+     * Return the value as a stringified number (12345.6789)
+     */
+    readonly number: NumberFormatter;
+    /**
+     * Return the value as a commas-separated stringified number (12,345.6789)
+     */
+    readonly commas: CommasFormatter;
+    /**
+     * Return the value as a shorted stringified number (12.3456789k)
+     */
+    readonly short: ShortFormatter;
+    /**
+     * Return the value as a percent based stringified number (10.00 instead of 0.1)
+     */
+    readonly percent: PercentFormatter;
+};
+export {};