@morpho-org/blue-sdk 1.0.2 → 1.0.4

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;
+};

package/lib/tests/mocks/markets.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAINNET_MARKETS = void 0;
+const ethers_1 = require("ethers");
+const market_1 = require("../../market");
+exports.MAINNET_MARKETS = {
+    eth_wstEth: new market_1.MarketConfig({
+        loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0x2a01EB9496094dA03c4E364Def50f5aD1280AD72",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.945"),
+    }),
+    eth_rEth: new market_1.MarketConfig({
+        loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        collateralToken: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+        oracle: "0x1b4A3F92e5Fffd1d35A98751c9FE4472483579bB",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.945"),
+    }),
+    usdt_wbtc: new market_1.MarketConfig({
+        loanToken: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        collateralToken: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+        oracle: "0x008bF4B1cDA0cc9f0e882E0697f036667652E1ef",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+    }),
+    usdt_wstEth: new market_1.MarketConfig({
+        loanToken: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0x95DB30fAb9A3754e42423000DF27732CB2396992",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+    }),
+    usdc_wbtc: new market_1.MarketConfig({
+        // USDC(wBTC, 86%, Chainlink, AdaptiveCurve)
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+        oracle: "0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+    }),
+    usdc_wstEth: new market_1.MarketConfig({
+        // USDC(wstETH, 86%, Chainlink, AdaptiveCurve)
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+        oracle: "0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+    }),
+    usdc_sDai: new market_1.MarketConfig({
+        // USDC(wstETH, 86%, Chainlink, AdaptiveCurve)
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: "0x83F20F44975D03b1b09e64809B757c47f942BEeA",
+        oracle: "0x6CAFE228eC0B0bC2D076577d56D35Fe704318f6d",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.965"),
+    }),
+    idle_usdc: new market_1.MarketConfig({
+        loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        collateralToken: ethers_1.ZeroAddress,
+        oracle: ethers_1.ZeroAddress,
+        irm: ethers_1.ZeroAddress,
+        lltv: 0n,
+    }),
+    crvUsd_stkcvxcrvUSDTWBTCWETH: new market_1.MarketConfig({
+        collateralToken: "0xb0Ce26C88e4e7DCa51968b6047f44646f5064278",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        oracle: "0x077Af6c2D4A75D4145d141F9e9421864C3940CB3",
+    }),
+    crvUsd_stkcvxcrvUSDCWBTCWETH: new market_1.MarketConfig({
+        collateralToken: "0x0ea1a65A2c255f24Ee8D81eA6AaC54Decd9d269e",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        oracle: "0xd2F7C3B2fC97cC7b6AfDd76D163394680EFc35b9",
+    }),
+    crvUsd_stkcvxcrvCRVUSDTBTCWSTETH: new market_1.MarketConfig({
+        collateralToken: "0x3ce8Ec9f3d89aD0A2DdbCC3FDB8991BD241Fc82E",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        oracle: "0xa9f7900476F43C45Ebf56cEa669B9c960C176112",
+    }),
+    crvUsd_stkcvxTryLSD: new market_1.MarketConfig({
+        collateralToken: "0x6BA072F0d22806F2C52e9792AF47f2D59103BEBE",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        oracle: "0x18B0d7311a97c5377445C80c768ab5201Bb27B5a",
+    }),
+    crvUsd_stkcvxcrvUSDETHCRV: new market_1.MarketConfig({
+        collateralToken: "0xAc904BAfBb5FB04Deb2b6198FdCEedE75a78Ce5a",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+        loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+        oracle: "0xad7e157815df05029125B568E39d5402550d60bb",
+    }),
+    usda_re7Eth: new market_1.MarketConfig({
+        collateralToken: "0x78Fc2c2eD1A4cDb5402365934aE5648aDAd094d0",
+        irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+        lltv: (0, ethers_1.parseUnits)("0.86"),
+        loanToken: "0x0000206329b97DB379d5E1Bf586BbDB969C63274",
+        oracle: "0x76052A2A28fDCB8124f4686C63C68355b142de3B",
+    }),
+};

package/lib/token/ERC20Metadata.d.ts

@@ -0,0 +1,249 @@
+import { ContractRunner } from "ethers";
+import { ERC20, ERC20Interface } from "ethers-types/dist/token/ERC20/ERC20";
+import { ChainId } from "../chain";
+export declare const isBytes32ERC20Metadata: (address: string, chainId: ChainId) => boolean;
+export declare const decodeString: (bytes32OrStr: string) => string;
+export declare class Bytes32ERC20__factory {
+    static readonly abi: readonly [...({
+        readonly inputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "name_";
+            readonly type: "string";
+        }, {
+            readonly internalType: "string";
+            readonly name: "symbol_";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    } | {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+        readonly name: "Approval";
+        readonly type: "event";
+    } | {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+        readonly name: "Transfer";
+        readonly type: "event";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "spender";
+            readonly type: "address";
+        }];
+        readonly name: "allowance";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly name: "approve";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly name: "balanceOf";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [];
+        readonly name: "decimals";
+        readonly outputs: readonly [{
+            readonly internalType: "uint8";
+            readonly name: "";
+            readonly type: "uint8";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "subtractedValue";
+            readonly type: "uint256";
+        }];
+        readonly name: "decreaseAllowance";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "addedValue";
+            readonly type: "uint256";
+        }];
+        readonly name: "increaseAllowance";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [];
+        readonly name: "name";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [];
+        readonly name: "symbol";
+        readonly outputs: readonly [{
+            readonly internalType: "string";
+            readonly name: "";
+            readonly type: "string";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [];
+        readonly name: "totalSupply";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly name: "transfer";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    } | {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly name: "transferFrom";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
+    })[], {
+        readonly inputs: readonly [];
+        readonly name: "symbol";
+        readonly outputs: readonly [{
+            readonly name: "symbol";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "name";
+        readonly outputs: readonly [{
+            readonly name: "name";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    static createInterface(): ERC20Interface;
+    static connect(address: string, runner?: ContractRunner | null): ERC20;
+}
+export declare class ERC20Metadata__factory {
+    static connect(address: string, chainId: ChainId, runner?: ContractRunner | null): ERC20;
+}

package/lib/token/ERC20Metadata.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20Metadata__factory = exports.Bytes32ERC20__factory = exports.decodeString = exports.isBytes32ERC20Metadata = void 0;
+const ethers_1 = require("ethers");
+const ethers_types_1 = require("ethers-types");
+const addresses_1 = __importDefault(require("@morpho-org/blue-sdk/src/addresses"));
+const chain_1 = require("../chain");
+const isBytes32ERC20Metadata = (address, chainId) => {
+    switch (chainId) {
+        case chain_1.ChainId.EthMainnet:
+            return [addresses_1.default[chain_1.ChainId.EthMainnet].mkr].includes(address);
+        default:
+            return false;
+    }
+};
+exports.isBytes32ERC20Metadata = isBytes32ERC20Metadata;
+const decodeString = (bytes32OrStr) => {
+    if ((0, ethers_1.isHexString)(bytes32OrStr, 32))
+        return (0, ethers_1.decodeBytes32String)(bytes32OrStr);
+    return bytes32OrStr;
+};
+exports.decodeString = decodeString;
+const _bytes32ERC20Abi = [
+    ...ethers_types_1.ERC20__factory.abi.filter((fragment) => !("name" in fragment) ||
+        (fragment.name !== "name" && fragment.name !== "symbol")),
+    {
+        inputs: [],
+        name: "symbol",
+        outputs: [
+            {
+                name: "symbol",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "name",
+        outputs: [
+            {
+                name: "name",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+class Bytes32ERC20__factory {
+    static createInterface() {
+        return new ethers_1.Interface(_bytes32ERC20Abi);
+    }
+    static connect(address, runner) {
+        const erc20 = new ethers_1.Contract(address, _bytes32ERC20Abi, runner);
+        const name = erc20.name.bind(erc20);
+        erc20.name = Object.assign((...args) => name(...args).then(exports.decodeString), name);
+        const symbol = erc20.symbol.bind(erc20);
+        erc20.symbol = Object.assign((...args) => symbol(...args).then(exports.decodeString), symbol);
+        return erc20;
+    }
+}
+exports.Bytes32ERC20__factory = Bytes32ERC20__factory;
+Bytes32ERC20__factory.abi = _bytes32ERC20Abi;
+class ERC20Metadata__factory {
+    static connect(address, chainId, runner) {
+        if ((0, exports.isBytes32ERC20Metadata)(address, chainId))
+            return Bytes32ERC20__factory.connect(address, runner);
+        const erc20 = ethers_types_1.ERC20__factory.connect(address, runner);
+        const name = erc20.name.bind(erc20);
+        erc20.name = Object.assign((...args) => name(...args).catch(() => Bytes32ERC20__factory.connect(address, runner).name(...args)), name);
+        const symbol = erc20.symbol.bind(erc20);
+        erc20.symbol = Object.assign((...args) => symbol(...args).catch(() => Bytes32ERC20__factory.connect(address, runner).symbol(...args)), symbol);
+        return erc20;
+    }
+}
+exports.ERC20Metadata__factory = ERC20Metadata__factory;

package/lib/token/Token.d.ts

@@ -0,0 +1,45 @@
+import { BigNumberish } from "ethers";
+import { RoundingDirection } from "../maths";
+import { Address } from "../types";
+export interface InputToken {
+    address: Address;
+    decimals: number;
+    symbol: string;
+    name?: string;
+}
+export declare class Token implements InputToken {
+    /**
+     * The token's address.
+     */
+    readonly address: Address;
+    /**
+     * The token's number of decimals.
+     */
+    readonly decimals: number;
+    /**
+     * The token's symbol.
+     */
+    readonly symbol: string;
+    /**
+     * The name of the token (defaults to the symbol).
+     */
+    readonly name: string;
+    constructor({ address, decimals, symbol, name }: InputToken);
+}
+export declare class TokenWithPrice extends Token {
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price?: bigint;
+    constructor(token: InputToken, price?: bigint);
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount: BigNumberish, rounding?: RoundingDirection): bigint | null;
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount: BigNumberish, rounding?: RoundingDirection): bigint | null;
+}

package/lib/token/Token.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenWithPrice = exports.Token = void 0;
+const ethers_1 = require("ethers");
+const maths_1 = require("../maths");
+class Token {
+    constructor({ address, decimals, symbol, name }) {
+        this.address = address;
+        this.decimals = decimals;
+        this.symbol = symbol;
+        this.name = name ?? symbol;
+    }
+}
+exports.Token = Token;
+class TokenWithPrice extends Token {
+    constructor(token, price) {
+        super(token);
+        this.price = price;
+    }
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return null;
+        return maths_1.MathLib.mulDiv(amount, (0, ethers_1.parseUnits)("1", this.decimals), this.price, rounding);
+    }
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount, rounding = "Down") {
+        if (this.price == null)
+            return null;
+        return maths_1.MathLib.mulDiv(amount, this.price, (0, ethers_1.parseUnits)("1", this.decimals), rounding);
+    }
+}
+exports.TokenWithPrice = TokenWithPrice;

package/lib/token/TokenNamespace.d.ts

@@ -0,0 +1,18 @@
+import { Provider } from "ethers";
+import { ViewOverrides } from "ethers-types/dist/common";
+import { ChainId } from "../chain";
+import { Address } from "../types";
+import { Token as TokenClass } from "./Token";
+import { ConstantWrappedToken, ExchangeRateWrappedToken } from "./WrappedToken";
+export declare class Token extends TokenClass {
+}
+export { TokenWithPrice } from "./Token";
+export declare namespace Token {
+    function native(chainId: ChainId): Token;
+    function fetch(address: Address, runner: {
+        provider: Provider;
+    }, { chainId, overrides, }?: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<Token | ConstantWrappedToken | ExchangeRateWrappedToken>;
+}

package/lib/token/TokenNamespace.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenWithPrice = exports.Token = void 0;
+const ethers_types_1 = require("ethers-types");
+const addresses_1 = require("../addresses");
+const chain_1 = require("../chain");
+const ERC20Metadata_1 = require("./ERC20Metadata");
+const Token_1 = require("./Token");
+const WrappedToken_1 = require("./WrappedToken");
+class Token extends Token_1.Token {
+}
+exports.Token = Token;
+var Token_2 = require("./Token");
+Object.defineProperty(exports, "TokenWithPrice", { enumerable: true, get: function () { return Token_2.TokenWithPrice; } });
+(function (Token) {
+    function native(chainId) {
+        const currency = chain_1.ChainUtils.chainMetadata[chainId].nativeCurrency;
+        return new Token({ ...currency, address: addresses_1.NATIVE_ADDRESS });
+    }
+    Token.native = native;
+    async function fetch(address, runner, { chainId, overrides = {}, } = {}) {
+        chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
+        if (address === addresses_1.NATIVE_ADDRESS)
+            return Token.native(chainId);
+        const erc20 = ERC20Metadata_1.ERC20Metadata__factory.connect(address, chainId, runner);
+        const [decimals, symbol, name] = await Promise.all([
+            erc20.decimals(overrides),
+            erc20.symbol(overrides),
+            erc20.name(overrides),
+        ]);
+        const token = {
+            address,
+            decimals: parseInt(decimals.toString()),
+            symbol,
+            name,
+        };
+        const { wstEth, stEth } = (0, addresses_1.getChainAddresses)(chainId);
+        switch (address) {
+            case wstEth: {
+                if (stEth) {
+                    const wstEthToken = ethers_types_1.WStEth__factory.connect(wstEth, runner);
+                    const stEthPerWstEth = await wstEthToken.stEthPerToken(overrides);
+                    return new WrappedToken_1.ExchangeRateWrappedToken(token, stEth, stEthPerWstEth);
+                }
+                break;
+            }
+        }
+        const unwrapToken = (0, addresses_1.getUnwrappedToken)(address, chainId);
+        if (unwrapToken) {
+            return new WrappedToken_1.ConstantWrappedToken(token, unwrapToken, token.decimals); //TODO fetch underlying token's decimals if it can be different form token's decimals
+        }
+        return new Token(token);
+    }
+    Token.fetch = fetch;
+})(Token || (exports.Token = Token = {}));