@morpho-org/blue-sdk 1.0.2 → 1.0.4

package/lib/chain/chain.utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainUtils = void 0;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const errors_1 = require("../errors");
+const chain_constants_1 = require("./chain.constants");
+const chain_types_1 = require("./chain.types");
+var ChainUtils;
+(function (ChainUtils) {
+    ChainUtils.blueAvailableChains = chain_constants_1.BLUE_AVAILABLE_CHAINS;
+    ChainUtils.chainMetadata = chain_constants_1.CHAIN_METADATA;
+    ChainUtils.ChainId = chain_types_1.ChainId;
+    ChainUtils.toHexChainId = (chainId) => {
+        return `0x${chainId.toString(16)}`;
+    };
+    ChainUtils.getAllChainIds = () => (0, morpho_ts_1.values)(ChainUtils.ChainId).filter((value) => typeof value === "number");
+    ChainUtils.getAllChainLabels = () => Object.values(ChainUtils.ChainId).filter((value) => typeof value === "string");
+    ChainUtils.getTestnets = () => ChainUtils.getAllChainIds().filter((chainId) => chain_constants_1.CHAIN_METADATA[chainId].isTestnet);
+    function isSupported(chainId) {
+        return ChainUtils.blueAvailableChains.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 || (exports.ChainUtils = ChainUtils = {}));

package/lib/chain/index.js

@@ -0,0 +1,18 @@
+"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("./chain.utils"), exports);
+__exportStar(require("./chain.types"), exports);

package/lib/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const LIQUIDATION_CURSOR: bigint;
+export declare const MAX_LIQUIDATION_INCENTIVE_FACTOR: bigint;
+export declare const ORACLE_PRICE_OFFSET = 36;
+export declare const ORACLE_PRICE_SCALE: bigint;
+export declare const MAX_FEE: bigint;
+export declare const DEFAULT_SLIPPAGE_TOLERANCE: bigint;
+export declare const DEFAULT_TARGET_UTILIZATION: bigint;
+export declare const SECONDS_PER_YEAR: bigint;

package/lib/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECONDS_PER_YEAR = exports.DEFAULT_TARGET_UTILIZATION = exports.DEFAULT_SLIPPAGE_TOLERANCE = exports.MAX_FEE = exports.ORACLE_PRICE_SCALE = exports.ORACLE_PRICE_OFFSET = exports.MAX_LIQUIDATION_INCENTIVE_FACTOR = exports.LIQUIDATION_CURSOR = void 0;
+const ethers_1 = require("ethers");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+exports.LIQUIDATION_CURSOR = (0, ethers_1.parseEther)("0.3");
+exports.MAX_LIQUIDATION_INCENTIVE_FACTOR = (0, ethers_1.parseEther)("1.15");
+exports.ORACLE_PRICE_OFFSET = 36;
+exports.ORACLE_PRICE_SCALE = (0, ethers_1.parseUnits)("1", exports.ORACLE_PRICE_OFFSET);
+exports.MAX_FEE = (0, ethers_1.parseEther)("0.25"); // 25%
+exports.DEFAULT_SLIPPAGE_TOLERANCE = (0, ethers_1.parseEther)("0.0003"); // 0.03%
+exports.DEFAULT_TARGET_UTILIZATION = (0, ethers_1.parseEther)("0.92"); // 92%
+exports.SECONDS_PER_YEAR = morpho_ts_1.Time.s.from.y(1n);

package/lib/errors.d.ts

@@ -0,0 +1,37 @@
+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 class InvalidInterestAccrualError extends UnknownDataError {
+    readonly marketId: MarketId;
+    readonly timestamp: bigint;
+    readonly lastUpdate: bigint;
+    constructor(marketId: MarketId, timestamp: bigint, lastUpdate: bigint);
+}
+export declare class InvalidSignatureError extends Error {
+    readonly hash: string;
+    readonly signer: Address;
+    readonly recovered: Address;
+    constructor(hash: string, signer: Address, recovered: Address);
+}
+export type ErrorClass = new (...args: any[]) => Error;
+export declare function _try<T>(accessor: () => T, ...errorClasses: ErrorClass[]): T | undefined;

package/lib/errors.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._try = exports.InvalidSignatureError = exports.InvalidInterestAccrualError = exports.UnsupportedChainIdError = exports.UnknownVaultConfigError = exports.UnknownMarketConfigError = exports.UnknownTokenPriceError = exports.UnknownTokenError = exports.UnknownDataError = void 0;
+class UnknownDataError extends Error {
+}
+exports.UnknownDataError = UnknownDataError;
+class UnknownTokenError extends UnknownDataError {
+    constructor(address) {
+        super(`unknown token ${address}`);
+        this.address = address;
+    }
+}
+exports.UnknownTokenError = UnknownTokenError;
+class UnknownTokenPriceError extends UnknownDataError {
+    constructor(address) {
+        super(`unknown price of token ${address}`);
+        this.address = address;
+    }
+}
+exports.UnknownTokenPriceError = UnknownTokenPriceError;
+class UnknownMarketConfigError extends UnknownDataError {
+    constructor(marketId) {
+        super(`unknown config for market ${marketId}`);
+        this.marketId = marketId;
+    }
+}
+exports.UnknownMarketConfigError = UnknownMarketConfigError;
+class UnknownVaultConfigError extends UnknownDataError {
+    constructor(vault) {
+        super(`unknown config for vault ${vault}`);
+        this.vault = vault;
+    }
+}
+exports.UnknownVaultConfigError = UnknownVaultConfigError;
+class UnsupportedChainIdError extends Error {
+    constructor(chainId) {
+        super(`unsupported chain ${chainId}`);
+        this.chainId = chainId;
+    }
+}
+exports.UnsupportedChainIdError = UnsupportedChainIdError;
+class InvalidInterestAccrualError extends UnknownDataError {
+    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;
+    }
+}
+exports.InvalidInterestAccrualError = InvalidInterestAccrualError;
+class InvalidSignatureError extends Error {
+    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;
+    }
+}
+exports._try = _try;

package/lib/ethers/ethers.test.d.ts

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

package/lib/ethers/ethers.test.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const safeParseUnits_1 = require("./safeParseUnits");
+describe("safeParseNumber", () => {
+    it("should parse excessively small number", () => {
+        expect((0, safeParseUnits_1.safeParseNumber)(0.000000000000000000000000000000042, 18)).toEqual(0n);
+    });
+    it("should parse excessively large number", () => {
+        expect((0, safeParseUnits_1.safeParseNumber)(4200000000000000000000000000000000000, 18).toString()).toEqual(4200000000000000000000000000000000000000000000000000000n.toString());
+    });
+});

package/lib/ethers/index.js

@@ -0,0 +1,18 @@
+"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("./safeGetAddress"), exports);
+__exportStar(require("./safeParseUnits"), exports);

package/lib/ethers/safeGetAddress.d.ts

@@ -0,0 +1 @@
+export declare const safeGetAddress: (address: string) => string;

package/lib/ethers/safeGetAddress.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeGetAddress = void 0;
+const ethers_1 = require("ethers");
+const safeGetAddress = (address) => (0, ethers_1.getAddress)(address.toLowerCase());
+exports.safeGetAddress = safeGetAddress;

package/lib/ethers/safeParseUnits.d.ts

@@ -0,0 +1,2 @@
+export declare const safeParseUnits: (strValue: string, decimals?: number) => bigint;
+export declare function safeParseNumber(value: number, decimals?: number): bigint;

package/lib/ethers/safeParseUnits.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeParseNumber = exports.safeParseUnits = void 0;
+const ethers_1 = require("ethers");
+const safeParseUnits = (strValue, decimals = 18) => {
+    if (!/[-+]?[0-9]*\.?[0-9]+/.test(strValue))
+        throw new Error("invalid number: " + strValue);
+    let [whole, dec = ""] = strValue.split(".");
+    dec = dec.slice(0, decimals);
+    return (0, ethers_1.parseUnits)([whole || "0", dec].filter((v) => v.length > 0).join("."), decimals);
+};
+exports.safeParseUnits = safeParseUnits;
+// Alternative to Number.toFixed that doesn't use scientific notation for excessively small or large numbers
+function toFixed(x, decimals) {
+    return new Intl.NumberFormat("en-US", {
+        style: "decimal",
+        useGrouping: false,
+        maximumFractionDigits: decimals,
+        minimumFractionDigits: decimals,
+    }).format(x);
+}
+function safeParseNumber(value, decimals = 18) {
+    return (0, exports.safeParseUnits)(toFixed(value, decimals), decimals);
+}
+exports.safeParseNumber = safeParseNumber;

package/lib/evm.d.ts

@@ -0,0 +1,36 @@
+import { TransactionRequest, Signer } from "ethers";
+import { ChainId } from "./chain";
+import { NotificationProducer, NotificationTopic } from "./notifications";
+import { SignatureMessage } from "./signatures/types";
+export interface NotificationOptions<Topic extends NotificationTopic> {
+    producer: NotificationProducer<Topic>;
+    id: string;
+    args: Record<PropertyKey, any>;
+}
+/**
+ * Sends a transaction via the provided signer, optionnally waiting for the corresponding transaction receipt.
+ * @param signer The signer to send the tx with.
+ * @param tx The transaction request.
+ * @param wait Whether to wait for the transaction receipt. Defaults to true.
+ * @param notificationOptions The optional notification options. Warning: if `wait` is set to true, the provided topic will never complete.
+ */
+export declare const sendTransactionWithProducer: (signer: Signer, req: TransactionRequest, defaultGasLimit?: bigint, confirms?: number, notificationOptions?: NotificationOptions<NotificationTopic.tx>) => Promise<void>;
+/**
+ * Sends a transaction via the provided signer, optionnally waiting for the corresponding transaction receipt.
+ * @param signer The signer to send the tx with.
+ * @param tx The transaction request.
+ * @param wait Whether to wait for the transaction receipt. Defaults to true.
+ * @param topic The type of notifications to emit.
+ * @param args The optional notification arguments.
+ * @return The notification consumer which receives the transaction notifications.
+ */
+export declare const sendTransaction: (signer: Signer, tx: TransactionRequest, defaultGasLimit?: bigint, confirms?: number, args?: Record<PropertyKey, any>) => import("./notifications").NotificationConsumer<NotificationTopic.tx>;
+export declare const signMessageWithProducer: (signer: Signer, message: SignatureMessage, notificationOptions?: NotificationOptions<NotificationTopic.signature>) => Promise<void>;
+/**
+ * Sends a signature request to the provided signer.
+ * @param signer The signer to send the approval with.
+ * @param args The approval parameters.
+ * @param encodeMessage The approval encoder to pass the approval parameters to get the approval transactions.
+ * @return The notification consumer which receives the transaction notifications.
+ */
+export declare const signMessage: <T extends object>(signer: Signer, args: T, encodeMessage: (args: T, chainId: ChainId) => SignatureMessage, chainId: ChainId) => import("./notifications").NotificationConsumer<NotificationTopic.signature>;

package/lib/evm.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signMessage = exports.signMessageWithProducer = exports.sendTransaction = exports.sendTransactionWithProducer = void 0;
+const ethers_1 = require("ethers");
+const maths_1 = require("./maths");
+const notifications_1 = require("./notifications");
+const signatures_1 = require("./signatures");
+/**
+ * Sends a transaction via the provided signer, optionnally waiting for the corresponding transaction receipt.
+ * @param signer The signer to send the tx with.
+ * @param tx The transaction request.
+ * @param wait Whether to wait for the transaction receipt. Defaults to true.
+ * @param notificationOptions The optional notification options. Warning: if `wait` is set to true, the provided topic will never complete.
+ */
+const sendTransactionWithProducer = async (signer, req, defaultGasLimit, confirms = 1, notificationOptions) => {
+    let response;
+    try {
+        let gasLimit;
+        try {
+            gasLimit = maths_1.MathLib.wMulUp(await signer.estimateGas(req), (0, ethers_1.parseUnits)("1.1"));
+        }
+        catch (error) {
+            if (defaultGasLimit == null)
+                throw error;
+            gasLimit = defaultGasLimit;
+        }
+        const tx = { ...req, gasLimit };
+        notificationOptions?.producer.next({
+            id: notificationOptions.id,
+            status: notifications_1.NotificationStatus.signing,
+            context: { tx },
+        });
+        response = await signer.sendTransaction(tx);
+        notificationOptions?.producer.next({
+            id: notificationOptions.id,
+            status: notifications_1.NotificationStatus.pending,
+            context: { args: notificationOptions.args, tx, response },
+        });
+        const receipt = await response.wait(confirms);
+        notificationOptions?.producer.next({
+            id: notificationOptions.id,
+            status: notifications_1.NotificationStatus.success,
+            context: { args: notificationOptions.args, tx, response, receipt },
+        });
+    }
+    catch (error) {
+        notificationOptions?.producer.next({
+            id: notificationOptions.id,
+            status: notifications_1.NotificationStatus.error,
+            context: { args: notificationOptions.args, tx: req, response, error },
+        });
+    }
+};
+exports.sendTransactionWithProducer = sendTransactionWithProducer;
+/**
+ * Sends a transaction via the provided signer, optionnally waiting for the corresponding transaction receipt.
+ * @param signer The signer to send the tx with.
+ * @param tx The transaction request.
+ * @param wait Whether to wait for the transaction receipt. Defaults to true.
+ * @param topic The type of notifications to emit.
+ * @param args The optional notification arguments.
+ * @return The notification consumer which receives the transaction notifications.
+ */
+const sendTransaction = (signer, tx, defaultGasLimit, confirms, args = {}) => {
+    const producer = new notifications_1.NotificationProducer(notifications_1.NotificationTopic.tx);
+    (0, exports.sendTransactionWithProducer)(signer, tx, defaultGasLimit, confirms, {
+        producer,
+        id: Date.now().toString(),
+        args,
+    });
+    return producer.consumer;
+};
+exports.sendTransaction = sendTransaction;
+const signMessageWithProducer = async (signer, message, notificationOptions) => {
+    notificationOptions?.producer.next({
+        id: notificationOptions.id,
+        status: notifications_1.NotificationStatus.signing,
+    });
+    try {
+        const signature = await signatures_1.SignatureUtils.safeSignTypedData(signer, message.data.domain, message.data.types, message.data.value);
+        signatures_1.SignatureUtils.verifySignature(signature, message.hash, await signer.getAddress());
+        notificationOptions?.producer.next({
+            id: notificationOptions.id,
+            status: notifications_1.NotificationStatus.success,
+            context: { message, args: notificationOptions.args, signature },
+        });
+    }
+    catch (error) {
+        notificationOptions?.producer.next({
+            id: notificationOptions.id,
+            status: notifications_1.NotificationStatus.error,
+            context: { message, args: notificationOptions.args, error },
+        });
+    }
+};
+exports.signMessageWithProducer = signMessageWithProducer;
+/**
+ * Sends a signature request to the provided signer.
+ * @param signer The signer to send the approval with.
+ * @param args The approval parameters.
+ * @param encodeMessage The approval encoder to pass the approval parameters to get the approval transactions.
+ * @return The notification consumer which receives the transaction notifications.
+ */
+const signMessage = (signer, args, encodeMessage, chainId) => {
+    const producer = new notifications_1.NotificationProducer(notifications_1.NotificationTopic.signature);
+    (0, exports.signMessageWithProducer)(signer, encodeMessage(args, chainId), {
+        producer,
+        id: Date.now().toString(),
+        args,
+    });
+    return producer.consumer;
+};
+exports.signMessage = signMessage;

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

@@ -0,0 +1,98 @@
+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;
+    }
+}
+export declare abstract class BaseFormatter {
+    protected abstract _options: FormatOptions;
+    constructor();
+    of(value: bigint, decimals: number): string;
+    of(value: number): string;
+}
+export declare class HexFormatter extends BaseFormatter {
+    protected _options: {
+        format: Format;
+    };
+}
+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;
+}
+export declare class NumberFormatter extends CommonFormatter {
+    protected _options: FormatNumberOptions;
+}
+export declare class CommasFormatter extends CommonFormatter {
+    protected _options: FormatCommasOptions;
+}
+export declare class ShortFormatter extends CommonFormatter {
+    protected _options: FormatShortOptions;
+    smallValuesWithCommas(): this;
+}
+export declare class PercentFormatter extends CommonFormatter {
+    protected _options: FormatPercentOptions;
+}
+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 {};