@morpho-org/blue-sdk 1.0.3 → 1.0.4

package/lib/position/Position.js

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

package/lib/position/index.js

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

package/lib/signatures/index.d.ts

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

package/lib/signatures/index.js

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

package/lib/signatures/manager.d.ts

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

package/lib/signatures/manager.js

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

package/lib/signatures/permit.d.ts

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

package/lib/signatures/permit.js

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

package/lib/signatures/permit2.d.ts

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

package/lib/signatures/permit2.js

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

package/lib/signatures/types.d.ts

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

package/lib/signatures/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/signatures/utils.d.ts

@@ -0,0 +1,6 @@
+import { Signature, Signer, TypedDataDomain, TypedDataField } from "ethers";
+import { Address } from "../types";
+import { SignatureMessage } from "./types";
+export declare function safeSignTypedData(signer: Signer, domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<Signature>;
+export declare function verifySignature(signature: Signature, hash: string, signerAddress: Address): void;
+export declare function getMessage(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): SignatureMessage;

package/lib/signatures/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMessage = exports.verifySignature = exports.safeSignTypedData = void 0;
+const ethers_1 = require("ethers");
+const errors_1 = require("../errors");
+async function safeSignTypedData(signer, domain, types, value) {
+    const populated = await ethers_1.TypedDataEncoder.resolveNames(domain, types, value, (name) => {
+        return signer.resolveName(name);
+    });
+    // Fix the chainId parsing issue
+    // Tracking of https://github.com/ethers-io/ethers.js/issues/4649
+    const initialPayload = ethers_1.TypedDataEncoder.getPayload(populated.domain, types, populated.value);
+    const provider = signer.provider;
+    const unsafeChainId = Number(initialPayload.domain.chainId);
+    if (provider && "send" in provider && Number.isSafeInteger(unsafeChainId)) {
+        const correctedPayload = {
+            ...initialPayload,
+            domain: {
+                ...initialPayload.domain,
+                chainId: unsafeChainId, // that is safe now
+            },
+        };
+        return ethers_1.Signature.from(
+        // @ts-ignore if send is defined in the provider, it accepts raw RPC call args
+        await signer.provider.send("eth_signTypedData_v4", [
+            // Doing the same thing that inside of the signTypedData function.
+            await signer.getAddress().then((r) => r.toLowerCase()),
+            JSON.stringify(correctedPayload),
+        ]));
+    }
+    return ethers_1.Signature.from(await signer.signTypedData(populated.domain, types, populated.value));
+}
+exports.safeSignTypedData = safeSignTypedData;
+function verifySignature(signature, hash, signerAddress) {
+    const recoveredAddress = (0, ethers_1.recoverAddress)(hash, signature);
+    if (recoveredAddress === ethers_1.ZeroAddress || recoveredAddress !== signerAddress)
+        throw new errors_1.InvalidSignatureError(hash, signerAddress, recoveredAddress);
+}
+exports.verifySignature = verifySignature;
+function getMessage(domain, types, value) {
+    const hash = ethers_1.TypedDataEncoder.hash(domain, types, value);
+    return { data: { domain, types, value }, hash };
+}
+exports.getMessage = getMessage;

package/lib/tests/mocks/markets.d.ts

@@ -0,0 +1,17 @@
+import { MarketConfig } from "../../market";
+export declare const MAINNET_MARKETS: {
+    eth_wstEth: MarketConfig;
+    eth_rEth: MarketConfig;
+    usdt_wbtc: MarketConfig;
+    usdt_wstEth: MarketConfig;
+    usdc_wbtc: MarketConfig;
+    usdc_wstEth: MarketConfig;
+    usdc_sDai: MarketConfig;
+    idle_usdc: MarketConfig;
+    crvUsd_stkcvxcrvUSDTWBTCWETH: MarketConfig;
+    crvUsd_stkcvxcrvUSDCWBTCWETH: MarketConfig;
+    crvUsd_stkcvxcrvCRVUSDTBTCWSTETH: MarketConfig;
+    crvUsd_stkcvxTryLSD: MarketConfig;
+    crvUsd_stkcvxcrvUSDETHCRV: MarketConfig;
+    usda_re7Eth: MarketConfig;
+};