@morpho-org/blue-sdk 1.0.0 → 1.0.1

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 = {}));

package/lib/token/WrappedToken.d.ts

@@ -0,0 +1,42 @@
+import { RoundingDirection } from "../maths";
+import { Address } from "../types";
+import { Vault } from "../vault";
+import { InputToken, Token } from "./Token";
+export declare abstract class WrappedToken extends Token {
+    readonly underlying: Address;
+    protected abstract _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected abstract _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected _noSlippage: boolean;
+    constructor(token: InputToken, underlying: Address);
+    /** The expected amount when wrapping `unwrappedAmount` */
+    toWrappedExactAmountIn(unwrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount: bigint, slippage?: bigint, rounding?: RoundingDirection): bigint;
+}
+export declare class ConstantWrappedToken extends WrappedToken {
+    readonly underlying: Address;
+    private readonly _underlyingDecimals;
+    protected _noSlippage: boolean;
+    constructor(token: InputToken, underlying: Address, _underlyingDecimals?: number);
+    protected _wrap(amount: bigint): bigint;
+    protected _unwrap(amount: bigint): bigint;
+}
+export declare class ExchangeRateWrappedToken extends WrappedToken {
+    readonly underlying: Address;
+    wrappedTokenExchangeRate: bigint;
+    protected _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+    constructor(token: InputToken, underlying: Address, wrappedTokenExchangeRate: bigint);
+}
+export declare class VaultToken extends WrappedToken {
+    readonly underlying: Address;
+    protected _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+    totalAssets: bigint;
+    totalSupply: bigint;
+    constructor(token: InputToken, underlying: Address, { totalAssets, totalSupply }: Pick<Vault, "totalAssets" | "totalSupply">);
+}

package/lib/token/WrappedToken.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultToken = exports.ExchangeRateWrappedToken = exports.ConstantWrappedToken = exports.WrappedToken = void 0;
+const ethers_1 = require("ethers");
+const ethers_2 = require("../ethers");
+const maths_1 = require("../maths");
+const Token_1 = require("./Token");
+class WrappedToken extends Token_1.Token {
+    constructor(token, underlying) {
+        super(token);
+        this.underlying = underlying;
+        this._noSlippage = false;
+    }
+    /** The expected amount when wrapping `unwrappedAmount` */
+    toWrappedExactAmountIn(unwrappedAmount, slippage = 0n, rounding = "Down") {
+        const wrappedAmount = this._wrap(unwrappedAmount, rounding);
+        if (this._noSlippage)
+            return wrappedAmount;
+        return maths_1.MathLib.wMul(wrappedAmount, maths_1.MathLib.WAD - slippage, "Down");
+    }
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount, slippage = 0n, rounding = "Up") {
+        const wAmountTarget = this._noSlippage
+            ? wrappedAmount
+            : maths_1.MathLib.wDiv(wrappedAmount, maths_1.MathLib.WAD - slippage, rounding);
+        return this._unwrap(wAmountTarget, rounding);
+    }
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount, slippage = 0n, rounding = "Down") {
+        const unwrappedAmount = this._unwrap(wrappedAmount, rounding);
+        if (this._noSlippage)
+            return unwrappedAmount;
+        return maths_1.MathLib.wMul(unwrappedAmount, maths_1.MathLib.WAD - slippage, "Up");
+    }
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount, slippage = 0n, rounding = "Up") {
+        const unwrappedAmountToTarget = this._noSlippage
+            ? unwrappedAmount
+            : maths_1.MathLib.wDiv(unwrappedAmount, maths_1.MathLib.WAD - slippage, rounding);
+        return this._wrap(unwrappedAmountToTarget, rounding);
+    }
+}
+exports.WrappedToken = WrappedToken;
+class ConstantWrappedToken extends WrappedToken {
+    constructor(token, underlying, _underlyingDecimals = 18) {
+        super(token, underlying);
+        this.underlying = underlying;
+        this._underlyingDecimals = _underlyingDecimals;
+        this._noSlippage = true;
+    }
+    _wrap(amount) {
+        return (0, ethers_2.safeParseUnits)((0, ethers_1.formatUnits)(amount, this._underlyingDecimals), this.decimals);
+    }
+    _unwrap(amount) {
+        return (0, ethers_2.safeParseUnits)((0, ethers_1.formatUnits)(amount, this.decimals), this._underlyingDecimals);
+    }
+}
+exports.ConstantWrappedToken = ConstantWrappedToken;
+class ExchangeRateWrappedToken extends WrappedToken {
+    _wrap(amount, rounding) {
+        return maths_1.MathLib.wDiv(amount, this.wrappedTokenExchangeRate, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return maths_1.MathLib.wMul(amount, this.wrappedTokenExchangeRate, rounding);
+    }
+    constructor(token, underlying, wrappedTokenExchangeRate) {
+        super(token, underlying);
+        this.underlying = underlying;
+        this.wrappedTokenExchangeRate = wrappedTokenExchangeRate;
+    }
+}
+exports.ExchangeRateWrappedToken = ExchangeRateWrappedToken;
+class VaultToken extends WrappedToken {
+    _wrap(amount, rounding) {
+        return maths_1.SharesMath.toShares(amount, this.totalAssets, this.totalSupply, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return maths_1.SharesMath.toAssets(amount, this.totalAssets, this.totalSupply, rounding);
+    }
+    constructor(token, underlying, { totalAssets, totalSupply }) {
+        super(token, underlying);
+        this.underlying = underlying;
+        this.totalAssets = totalAssets;
+        this.totalSupply = totalSupply;
+    }
+}
+exports.VaultToken = VaultToken;

package/lib/token/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("./TokenNamespace"), exports);
+__exportStar(require("./WrappedToken"), exports);

package/lib/types.d.ts

@@ -0,0 +1,29 @@
+export type Hex64 = string & {
+    __LENGTH__: 64;
+};
+/**
+ * The address of a Contract, or an EOA
+ */
+export type Address = string;
+/**
+ * The id of a market used on the Blue contract
+ */
+export type MarketId = `0x${Hex64}` & {
+    __TYPE__: "marketId";
+};
+/**
+ * The possible transaction type on the Blue contract
+ */
+export declare enum TransactionType {
+    Supply = "Supply",
+    SupplyCollateral = "Supply Collateral",
+    Withdraw = "Withdraw",
+    WithdrawCollateral = "Withdraw Collateral",
+    Borrow = "Borrow",
+    Repay = "Repay"
+}
+export type Loadable<T> = T | undefined;
+export type Failable<T> = T | null;
+export type Fetchable<T> = Failable<Loadable<T>>;
+export declare function isFetched<T>(v: Fetchable<T>): v is T;
+export declare const isMarketId: (value: any) => value is MarketId;