@lagoon-protocol/v0-core 0.1.2

package/README.md

@@ -0,0 +1,98 @@
+# @lagoon-protocol/v0-core
+
+Framework-agnostic package that defines Lagoon vault entity classes, inspired by [@morpho-org/blue-sdk](https://github.com/morpho-org/sdks/tree/main/packages/blue-sdk) architecture:
+
+- [**Vault**](./src/vault/Vault.ts): represents the state of a Lagoon vault
+
+- [**Token**](./src/token/Token.ts): represents an ERC20 token
+
+## How to install
+
+```bash
+npm install @lagoon-protocol/v0-core
+```
+
+```bash
+bun install @lagoon-protocol/v0-core
+```
+
+## How to use
+
+```typescript
+import { Vault, Token } from '@lagoon-protocol/v0-core';
+import { VaultUtils } from "@lagoon-protocol/v0-core";
+import { addresses, ChainId, Version } from "@lagoon-protocol/v0-core";
+
+const UINT256_MAX = 2n ** 256n - 1n;
+
+const tacUSN = new Vault({
+  address: '0x7895A046b26CC07272B022a0C9BAFC046E6F6396',
+  name: 'Noon tacUSN',
+  symbol: 'tacUSN',
+  decimals: 18,
+  price: undefined,
+  asset: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+  underlyingDecimals: 6,
+  totalAssets: 0n,
+  newTotalAssets: UINT256_MAX,
+  depositEpochId: 1,
+  depositSettleId: 1,
+  lastDepositEpochIdSettled: 0,
+  redeemEpochId: 2,
+  redeemSettleId: 2,
+  lastRedeemEpochIdSettled: 0,
+  pendingSilo: '0x65D57bb5fB43fc227518D7c983e83388D4017687',
+  wrappedNativeToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  decimalsOffset: 12,
+  totalAssetsExpiration: 0n,
+  totalAssetsLifespan: 0n,
+  feeRegistry: addresses[ChainId.EthMainnet].feeRegistry,
+  newRatesTimestamp: 1744463627n,
+  lastFeeTime: 0n,
+  highWaterMark: 1000000n,
+  cooldown: 0n,
+  feeRates: { managementRate: 50, performanceRate: 1000 },
+  owner: '0xA766CdA5848FfD7D33cE3861f6dc0A5EE38f3550',
+  pendingOwner: '0x0000000000000000000000000000000000000000',
+  whitelistManager: '0x0000000000000000000000000000000000000000',
+  feeReceiver: '0xa336DA6a81EFfa40362D2763d81643a67C82D151',
+  safe: '0xA766CdA5848FfD7D33cE3861f6dc0A5EE38f3550',
+  valuationManager: '0xF53eAeB7e6f15CBb6dB990eaf2A26702e1D986d8',
+  state: 0,
+  isWhitelistActivated: false,
+  version: Version.v0_4_0,
+  totalSupply: 0n
+})
+
+tacUSN.name // Noon tacUSN
+tacUSN.simbol // tacUSN
+
+tacUSN.convertToShares(BigInt(10 ** tacUSN.underlyingDecimals));
+tacUSN.convertToAssets(VaultUtils.ONE_SHARE);
+
+```
+
+
+## Local development:
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run test
+```
+
+This project was created using `bun init` in bun v1.2.9. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+
+## Disclaimer ⚠️
+
+This SDK is provided on a best-effort basis by the Lagoon team to facilitate integration with Lagoon Vaults. While we strive to ensure the accuracy, reliability, and security of this software, it is provided “as is” without any guarantees or warranties of any kind, express or implied.
+
+Lagoon and its contributors accept no responsibility or liability for any loss, damage, or other consequences resulting from the use, misuse, or inability to use this SDK. It is the responsibility of the integrator to perform appropriate testing, due diligence, and security assessments before deploying or relying on this software in production environments.
+
+By using this SDK, you acknowledge and agree to assume all associated risks.

package/dist/addresses.d.ts

@@ -0,0 +1,66 @@
+export declare const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export type ChainAddresses = typeof addresses;
+export declare const addresses: {
+    readonly 1: {
+        readonly beaconProxyFactory: "0x09C8803f7Dc251f9FaAE5f56E3B91f8A6d0b70ee";
+        readonly feeRegistry: "0x6dA4D1859bA1d02D095D2246142CdAd52233e27C";
+        readonly v0_5_0: "0xe50554ec802375c9c3f9c087a8a7bb8c26d3dedf";
+        readonly wrappedNative: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+    };
+    readonly 42161: {
+        readonly beaconProxyFactory: "0x58a7729125acA9e5E9C687018E66bfDd5b2D4490";
+        readonly feeRegistry: "0x6dA4D1859bA1d02D095D2246142CdAd52233e27C";
+        readonly v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf";
+        readonly wrappedNative: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1 ";
+        /**
+        * @dev Events not indexed
+        */
+        readonly dev: {
+            readonly beaconProxyFactory: "0x29f3dba953C57814A5579e08462724B9C760333e";
+            readonly feeRegistry: "0x45BA44B8899D39abdc383a25bB17fcD18240c6Bc";
+        };
+    };
+    readonly 8453: {
+        readonly beaconProxyFactory: "0xC953Fd298FdfA8Ed0D38ee73772D3e21Bf19c61b";
+        readonly feeRegistry: "0x6dA4D1859bA1d02D095D2246142CdAd52233e27C";
+        readonly v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf";
+        readonly wrappedNative: "0x4200000000000000000000000000000000000006";
+    };
+    readonly 130: {
+        readonly beaconProxyFactory: "0xaba1A2e157Dae248f8630cA550bd826725Ff745c";
+        readonly feeRegistry: "0x652716FaD571f04D26a3c8fFd9E593F17123Ab20";
+        readonly v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf";
+        readonly wrappedNative: "0x4200000000000000000000000000000000000006";
+    };
+    readonly 80094: {
+        readonly beaconProxyFactory: "0x7cf8cf276450bd568187fdc0b0959d30ec599853";
+        readonly feeRegistry: "0xaba1A2e157Dae248f8630cA550bd826725Ff745c";
+        readonly v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf";
+        readonly wrappedNative: "0x6969696969696969696969696969696969696969";
+    };
+    readonly 146: {
+        readonly beaconProxyFactory: "0x99CD0b8b32B15922f0754Fddc21323b5278c5261";
+        readonly feeRegistry: "0xab4aC28D10a4Bc279aD073B1D74Bfa0E385C010C";
+        readonly v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf";
+        readonly wrappedNative: "0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38";
+    };
+    readonly 5000: {
+        readonly beaconProxyFactory: "0x57D969B556C6AebB3Ac8f54c98CF3a3f921d5659";
+        readonly feeRegistry: "0x47A144e67834408716cB40Fa87fc886D63362ddC";
+        readonly v0_4_0: "0xA7260Cee56B679eC05a736A7b603b8DA8525Dd69";
+        readonly wrappedNative: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8";
+    };
+    readonly 480: {
+        readonly beaconProxyFactory: "0x600fA26581771F56221FC9847A834B3E5fd34AF7";
+        readonly feeRegistry: "0x68e793658def657551fd4D3cA6Bc04b4E7723655";
+        readonly v0_5_0: "0x1D42DbDde553F4099691A25F712bbd8f2686E355 ";
+        readonly wrappedNative: "0x4200000000000000000000000000000000000006";
+    };
+    readonly 43114: {
+        readonly beaconProxyFactory: "0x5e231c6d030a5c0f51fa7d0f891d3f50a928c685";
+        readonly feeRegistry: "0xD7F69ba99c6981Eab5579Aa16871Ae94c509d578";
+        readonly v0_5_0: "0x33F65C8D025b5418C7f8dd248C2Ec1d31881D465";
+        readonly wrappedNative: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7";
+    };
+};
+//# sourceMappingURL=addresses.d.ts.map

package/dist/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../src/addresses.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,+CAA+C,CAAC;AAE3E,MAAM,MAAM,cAAc,GAAG,OAAO,SAAS,CAAC;AAE9C,eAAO,MAAM,SAAS;;;;;;;;;;;;QAYlB;;UAEE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDI,CAAA"}

package/dist/chain.d.ts

@@ -0,0 +1,250 @@
+export declare enum ChainId {
+    EthMainnet = 1,
+    BaseMainnet = 8453,
+    PolygonMainnet = 137,
+    ArbitrumMainnet = 42161,
+    OptimismMainnet = 10,
+    WorldChainMainnet = 480,
+    FraxtalMainnet = 252,
+    ScrollMainnet = 534352,
+    InkMainnet = 57073,
+    UnichainMainnet = 130,
+    SonicMainnet = 146,
+    HemiMainnet = 43111,
+    ModeMainnet = 34443,
+    CornMainnet = 21000000,
+    PlumeMainnet = 98866,
+    CampMainnet = 123420001114,
+    BerachainMainnet = 80094,
+    MantleMainnet = 5000,
+    AvalancheMainnet = 43114
+}
+export interface ChainMetadata {
+    readonly name: string;
+    readonly id: ChainId;
+    readonly explorerUrl: string;
+    readonly nativeCurrency: {
+        readonly name: string;
+        readonly symbol: string;
+        readonly decimals: number;
+    };
+    readonly identifier: string;
+}
+export declare namespace ChainUtils {
+    const toHexChainId: (chainId: ChainId) => `0x${string}`;
+    const getExplorerUrl: <T extends ChainId>(chainId: T) => (typeof ChainUtils.CHAIN_METADATA)[T]["explorerUrl"];
+    const getExplorerAddressUrl: <T extends ChainId>(chainId: T, address: string) => `${(typeof ChainUtils.CHAIN_METADATA)[T]["explorerUrl"]}/address/${string}`;
+    const getExplorerTransactionUrl: <T extends ChainId>(chainId: T, tx: string) => `${(typeof ChainUtils.CHAIN_METADATA)[T]["explorerUrl"]}/tx/${string}`;
+    const CHAIN_METADATA: {
+        readonly 1: {
+            readonly name: "Ethereum";
+            readonly id: ChainId.EthMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://etherscan.io";
+            readonly identifier: "mainnet";
+        };
+        readonly 8453: {
+            readonly name: "Base";
+            readonly id: ChainId.BaseMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://basescan.org";
+            readonly identifier: "base";
+        };
+        readonly 137: {
+            readonly name: "Polygon";
+            readonly id: ChainId.PolygonMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Polygon";
+                readonly symbol: "POL";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://polygonscan.com";
+            readonly identifier: "polygon";
+        };
+        readonly 42161: {
+            readonly name: "Arbitrum One";
+            readonly id: ChainId.ArbitrumMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://arbiscan.io";
+            readonly identifier: "arbitrum";
+        };
+        readonly 10: {
+            readonly name: "OP Mainnet";
+            readonly id: ChainId.OptimismMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://optimistic.etherscan.io";
+            readonly identifier: "optimism";
+        };
+        readonly 480: {
+            readonly name: "World Chain";
+            readonly id: ChainId.WorldChainMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://worldscan.org";
+            readonly identifier: "worldchain";
+        };
+        readonly 252: {
+            readonly name: "Fraxtal";
+            readonly id: ChainId.FraxtalMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Frax Ether";
+                readonly symbol: "frxETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://fraxscan.com";
+            readonly identifier: "fraxtal";
+        };
+        readonly 534352: {
+            readonly name: "Scroll";
+            readonly id: ChainId.ScrollMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://scrollscan.com";
+            readonly identifier: "scroll";
+        };
+        readonly 57073: {
+            readonly name: "Ink";
+            readonly id: ChainId.InkMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://explorer.inkonchain.com";
+            readonly identifier: "ink";
+        };
+        readonly 130: {
+            readonly name: "Unichain";
+            readonly id: ChainId.UnichainMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://uniscan.xyz";
+            readonly identifier: "unichain";
+        };
+        readonly 146: {
+            readonly name: "Sonic";
+            readonly id: ChainId.SonicMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Sonic";
+                readonly symbol: "S";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://sonicscan.org";
+            readonly identifier: "sonic";
+        };
+        readonly 43111: {
+            readonly name: "Hemi";
+            readonly id: ChainId.HemiMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://explorer.hemi.xyz";
+            readonly identifier: "hemi";
+        };
+        readonly 34443: {
+            readonly name: "Mode";
+            readonly id: ChainId.ModeMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://modescan.io";
+            readonly identifier: "mode";
+        };
+        readonly 21000000: {
+            readonly name: "Corn";
+            readonly id: ChainId.CornMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Bitcoin";
+                readonly symbol: "BTCN";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://cornscan.io";
+            readonly identifier: "corn";
+        };
+        readonly 98866: {
+            readonly name: "Plume";
+            readonly id: ChainId.PlumeMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Plume";
+                readonly symbol: "PLUME";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://phoenix-explorer.plumenetwork.xyz";
+            readonly identifier: "plume";
+        };
+        readonly 123420001114: {
+            readonly name: "Camp";
+            readonly id: ChainId.CampMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Camp";
+                readonly symbol: "CAMP";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://basecamp.cloud.blockscout.com/";
+            readonly identifier: "camp";
+        };
+        readonly 80094: {
+            readonly name: "Berachain";
+            readonly id: ChainId.BerachainMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Bera";
+                readonly symbol: "BERA";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://berascan.com/";
+            readonly identifier: "berachain";
+        };
+        readonly 5000: {
+            readonly name: "Mantle";
+            readonly id: ChainId.MantleMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Mantle";
+                readonly symbol: "MNT";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://mantlescan.xyz/";
+            readonly identifier: "mantle";
+        };
+        readonly 43114: {
+            readonly name: "Avalanche";
+            readonly id: ChainId.AvalancheMainnet;
+            readonly nativeCurrency: {
+                readonly name: "Avalanche";
+                readonly symbol: "AVAX";
+                readonly decimals: 18;
+            };
+            readonly explorerUrl: "https://snowtrace.io";
+            readonly identifier: "avalanche";
+        };
+    };
+}
+//# sourceMappingURL=chain.d.ts.map

package/dist/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../src/chain.ts"],"names":[],"mappings":"AAAA,oBAAY,OAAO;IACjB,UAAU,IAAI;IACd,WAAW,OAAO;IAClB,cAAc,MAAM;IACpB,eAAe,QAAQ;IACvB,eAAe,KAAK;IACpB,iBAAiB,MAAM;IACvB,cAAc,MAAM;IACpB,aAAa,SAAS;IACtB,UAAU,QAAQ;IAClB,eAAe,MAAM;IACrB,YAAY,MAAM;IAClB,WAAW,QAAQ;IACnB,WAAW,QAAQ;IACnB,WAAW,WAAW;IACtB,YAAY,QAAQ;IACpB,WAAW,eAAe;IAC1B,gBAAgB,QAAQ;IACxB,aAAa,OAAO;IACpB,gBAAgB,QAAQ;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,yBAAiB,UAAU,CAAC;IACnB,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,KAAK,MAAM,EAE1D,CAAC;IAEK,MAAM,cAAc,GAAI,CAAC,SAAS,OAAO,EAAE,SAAS,CAAC,KAAG,CAAC,OAAO,UAAU,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,aAAa,CAEjH,CAAC;IAEK,MAAM,qBAAqB,GAAI,CAAC,SAAS,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,MAAM,KAAG,GAAG,CAAC,OAAO,UAAU,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,YAAY,MAAM,EAE/J,CAAC;IAEK,MAAM,yBAAyB,GAAI,CAAC,SAAS,OAAO,EAAE,SAAS,CAAC,EAAE,IAAI,MAAM,KAAG,GAAG,CAAC,OAAO,UAAU,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,MAAM,EAEzJ,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsIjB,CAAA;CACX"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./vault/";
+export * from "./math/";
+export * from "./token/";
+export * from "./addresses";
+export * from "./chain";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,533 @@
+// src/math/MathLib.ts
+var MathLib;
+((MathLib) => {
+  MathLib.WAD = 1000000000000000000n;
+  MathLib.RAY = 1000000000000000000000000000n;
+  MathLib.MAX_UINT_256 = maxUint(256);
+  MathLib.MAX_UINT_160 = maxUint(160);
+  MathLib.MAX_UINT_128 = maxUint(128);
+  MathLib.MAX_UINT_48 = maxUint(48);
+  function maxUint(nBits) {
+    if (nBits % 4 !== 0)
+      throw new Error(`Invalid number of bits: ${nBits}`);
+    return BigInt(`0x${"f".repeat(nBits / 4)}`);
+  }
+  MathLib.maxUint = maxUint;
+  function abs(a) {
+    a = BigInt(a);
+    return a >= 0 ? a : -a;
+  }
+  MathLib.abs = abs;
+  function min(...xs) {
+    return xs.map(BigInt).reduce((x, y) => x <= y ? x : y);
+  }
+  MathLib.min = min;
+  function max(...xs) {
+    return xs.map(BigInt).reduce((x, y) => x <= y ? y : x);
+  }
+  MathLib.max = max;
+  function zeroFloorSub(x, y) {
+    x = BigInt(x);
+    y = BigInt(y);
+    return x <= y ? 0n : x - y;
+  }
+  MathLib.zeroFloorSub = zeroFloorSub;
+  function wMulDown(x, y) {
+    return MathLib.wMul(x, y, "Down");
+  }
+  MathLib.wMulDown = wMulDown;
+  function wMulUp(x, y) {
+    return MathLib.wMul(x, y, "Up");
+  }
+  MathLib.wMulUp = wMulUp;
+  function wMul(x, y, rounding) {
+    return MathLib.mulDiv(x, y, MathLib.WAD, rounding);
+  }
+  MathLib.wMul = wMul;
+  function wDivDown(x, y) {
+    return MathLib.wDiv(x, y, "Down");
+  }
+  MathLib.wDivDown = wDivDown;
+  function wDivUp(x, y) {
+    return MathLib.wDiv(x, y, "Up");
+  }
+  MathLib.wDivUp = wDivUp;
+  function wDiv(x, y, rounding) {
+    return MathLib.mulDiv(x, MathLib.WAD, y, rounding);
+  }
+  MathLib.wDiv = wDiv;
+  function mulDivDown(x, y, denominator) {
+    x = BigInt(x);
+    y = BigInt(y);
+    denominator = BigInt(denominator);
+    if (denominator === 0n)
+      throw Error("MathLib: DIVISION_BY_ZERO");
+    return x * y / denominator;
+  }
+  MathLib.mulDivDown = mulDivDown;
+  function mulDivUp(x, y, denominator) {
+    x = BigInt(x);
+    y = BigInt(y);
+    denominator = BigInt(denominator);
+    if (denominator === 0n)
+      throw Error("MathLib: DIVISION_BY_ZERO");
+    const roundup = x * y % denominator > 0 ? 1n : 0n;
+    return x * y / denominator + roundup;
+  }
+  MathLib.mulDivUp = mulDivUp;
+  function mulDiv(x, y, denominator, rounding) {
+    return MathLib[`mulDiv${rounding}`](x, y, denominator);
+  }
+  MathLib.mulDiv = mulDiv;
+  function wTaylorCompounded(x, n) {
+    const firstTerm = BigInt(x) * BigInt(n);
+    const secondTerm = MathLib.mulDivDown(firstTerm, firstTerm, 2n * MathLib.WAD);
+    const thirdTerm = MathLib.mulDivDown(secondTerm, firstTerm, 3n * MathLib.WAD);
+    return firstTerm + secondTerm + thirdTerm;
+  }
+  MathLib.wTaylorCompounded = wTaylorCompounded;
+  function wToRay(x) {
+    return BigInt(x) * 1000000000n;
+  }
+  MathLib.wToRay = wToRay;
+})(MathLib ||= {});
+// src/token/Token.ts
+class Test {
+}
+
+class Token {
+  address;
+  name;
+  symbol;
+  decimals;
+  totalSupply;
+  price;
+  constructor({
+    address,
+    name,
+    symbol,
+    decimals = 0,
+    totalSupply,
+    price
+  }) {
+    this.address = address;
+    this.name = name;
+    this.symbol = symbol;
+    this.decimals = Number(decimals);
+    this.totalSupply = BigInt(totalSupply);
+    if (price != null)
+      this.price = BigInt(price);
+  }
+  fromUsd(amount, rounding = "Down") {
+    if (this.price == null)
+      return;
+    return MathLib.mulDiv(amount, 10n ** BigInt(this.decimals), this.price, rounding);
+  }
+  toUsd(amount, rounding = "Down") {
+    if (this.price == null)
+      return;
+    return MathLib.mulDiv(amount, this.price, 10n ** BigInt(this.decimals), rounding);
+  }
+}
+
+// src/vault/VaultUtils.ts
+var VaultUtils;
+((VaultUtils) => {
+  VaultUtils.VIRTUAL_ASSETS = 1n;
+  VaultUtils.ONE_SHARE = 10n ** 18n;
+  function decimalsOffset(decimals) {
+    return MathLib.zeroFloorSub(18n, decimals);
+  }
+  VaultUtils.decimalsOffset = decimalsOffset;
+  function convertToAssets(shares, {
+    totalAssets,
+    totalSupply,
+    decimalsOffset: decimalsOffset2
+  }, rounding = "Down") {
+    return MathLib.mulDiv(shares, BigInt(totalAssets) + VaultUtils.VIRTUAL_ASSETS, BigInt(totalSupply) + 10n ** BigInt(decimalsOffset2), rounding);
+  }
+  VaultUtils.convertToAssets = convertToAssets;
+  function convertToShares(assets, {
+    totalAssets,
+    totalSupply,
+    decimalsOffset: decimalsOffset2
+  }, rounding = "Up") {
+    return MathLib.mulDiv(assets, BigInt(totalSupply) + 10n ** BigInt(decimalsOffset2), BigInt(totalAssets) + VaultUtils.VIRTUAL_ASSETS, rounding);
+  }
+  VaultUtils.convertToShares = convertToShares;
+})(VaultUtils ||= {});
+
+// src/vault/Vault.ts
+var Version;
+((Version2) => {
+  Version2["v0_5_0"] = "v0.5.0";
+  Version2["v0_4_0"] = "v0.4.0";
+  Version2["v0_3_0"] = "v0.3.0";
+  Version2["v0_2_0"] = "v0.2.0";
+  Version2["v0_1_0"] = "v0.1.0";
+})(Version ||= {});
+var LATEST_VERSION = "v0.5.0" /* v0_5_0 */;
+function resolveVersion(version) {
+  return version === "latest" ? LATEST_VERSION : version;
+}
+var State;
+((State2) => {
+  State2[State2["Open"] = 0] = "Open";
+  State2[State2["Closing"] = 1] = "Closing";
+  State2[State2["Closed"] = 2] = "Closed";
+})(State ||= {});
+
+class Vault extends Token {
+  asset;
+  underlyingDecimals;
+  totalAssets;
+  newTotalAssets;
+  depositEpochId;
+  depositSettleId;
+  lastDepositEpochIdSettled;
+  redeemEpochId;
+  redeemSettleId;
+  lastRedeemEpochIdSettled;
+  pendingSilo;
+  wrappedNativeToken;
+  decimalsOffset;
+  totalAssetsExpiration;
+  totalAssetsLifespan;
+  feeRegistry;
+  newRatesTimestamp;
+  lastFeeTime;
+  highWaterMark;
+  cooldown;
+  feeRates;
+  owner;
+  pendingOwner;
+  whitelistManager;
+  feeReceiver;
+  safe;
+  valuationManager;
+  state;
+  isWhitelistActivated;
+  version;
+  constructor({
+    asset,
+    underlyingDecimals,
+    totalAssets,
+    newTotalAssets,
+    depositEpochId,
+    depositSettleId,
+    lastDepositEpochIdSettled,
+    redeemEpochId,
+    redeemSettleId,
+    lastRedeemEpochIdSettled,
+    pendingSilo,
+    wrappedNativeToken,
+    decimalsOffset,
+    totalAssetsExpiration,
+    totalAssetsLifespan,
+    feeRegistry,
+    newRatesTimestamp,
+    lastFeeTime,
+    highWaterMark,
+    cooldown,
+    feeRates,
+    owner,
+    pendingOwner,
+    whitelistManager,
+    feeReceiver,
+    safe,
+    valuationManager,
+    state,
+    isWhitelistActivated,
+    version,
+    ...config
+  }) {
+    super({ ...config, decimals: 18 });
+    this.asset = asset;
+    this.underlyingDecimals = underlyingDecimals;
+    this.totalAssets = totalAssets;
+    this.newTotalAssets = newTotalAssets;
+    this.depositEpochId = depositEpochId;
+    this.depositSettleId = depositSettleId;
+    this.lastDepositEpochIdSettled = lastDepositEpochIdSettled;
+    this.redeemEpochId = redeemEpochId;
+    this.redeemSettleId = redeemSettleId;
+    this.lastRedeemEpochIdSettled = lastRedeemEpochIdSettled;
+    this.pendingSilo = pendingSilo;
+    this.wrappedNativeToken = wrappedNativeToken;
+    this.decimalsOffset = decimalsOffset;
+    this.totalAssetsExpiration = totalAssetsExpiration;
+    this.totalAssetsLifespan = totalAssetsLifespan;
+    this.feeRegistry = feeRegistry;
+    this.newRatesTimestamp = newRatesTimestamp;
+    this.lastFeeTime = lastFeeTime;
+    this.highWaterMark = highWaterMark;
+    this.cooldown = cooldown;
+    this.feeRates = feeRates;
+    this.owner = owner;
+    this.pendingOwner = pendingOwner;
+    this.whitelistManager = whitelistManager;
+    this.feeReceiver = feeReceiver;
+    this.safe = safe;
+    this.valuationManager = valuationManager;
+    this.state = state;
+    this.isWhitelistActivated = isWhitelistActivated;
+    this.version = version;
+  }
+  convertToAssets(shares, rounding) {
+    return VaultUtils.convertToAssets(shares, { totalAssets: this.totalAssets, totalSupply: this.totalSupply, decimalsOffset: this.decimalsOffset }, rounding);
+  }
+  convertToShares(assets, rounding) {
+    return VaultUtils.convertToShares(assets, { totalAssets: this.totalAssets, totalSupply: this.totalSupply, decimalsOffset: this.decimalsOffset }, rounding);
+  }
+}
+// src/chain.ts
+var ChainId;
+((ChainId2) => {
+  ChainId2[ChainId2["EthMainnet"] = 1] = "EthMainnet";
+  ChainId2[ChainId2["BaseMainnet"] = 8453] = "BaseMainnet";
+  ChainId2[ChainId2["PolygonMainnet"] = 137] = "PolygonMainnet";
+  ChainId2[ChainId2["ArbitrumMainnet"] = 42161] = "ArbitrumMainnet";
+  ChainId2[ChainId2["OptimismMainnet"] = 10] = "OptimismMainnet";
+  ChainId2[ChainId2["WorldChainMainnet"] = 480] = "WorldChainMainnet";
+  ChainId2[ChainId2["FraxtalMainnet"] = 252] = "FraxtalMainnet";
+  ChainId2[ChainId2["ScrollMainnet"] = 534352] = "ScrollMainnet";
+  ChainId2[ChainId2["InkMainnet"] = 57073] = "InkMainnet";
+  ChainId2[ChainId2["UnichainMainnet"] = 130] = "UnichainMainnet";
+  ChainId2[ChainId2["SonicMainnet"] = 146] = "SonicMainnet";
+  ChainId2[ChainId2["HemiMainnet"] = 43111] = "HemiMainnet";
+  ChainId2[ChainId2["ModeMainnet"] = 34443] = "ModeMainnet";
+  ChainId2[ChainId2["CornMainnet"] = 21000000] = "CornMainnet";
+  ChainId2[ChainId2["PlumeMainnet"] = 98866] = "PlumeMainnet";
+  ChainId2[ChainId2["CampMainnet"] = 123420001114] = "CampMainnet";
+  ChainId2[ChainId2["BerachainMainnet"] = 80094] = "BerachainMainnet";
+  ChainId2[ChainId2["MantleMainnet"] = 5000] = "MantleMainnet";
+  ChainId2[ChainId2["AvalancheMainnet"] = 43114] = "AvalancheMainnet";
+})(ChainId ||= {});
+var ChainUtils;
+((ChainUtils) => {
+  ChainUtils.toHexChainId = (chainId) => {
+    return `0x${chainId.toString(16)}`;
+  };
+  ChainUtils.getExplorerUrl = (chainId) => {
+    return ChainUtils.CHAIN_METADATA[chainId].explorerUrl;
+  };
+  ChainUtils.getExplorerAddressUrl = (chainId, address) => {
+    return `${ChainUtils.getExplorerUrl(chainId)}/address/${address}`;
+  };
+  ChainUtils.getExplorerTransactionUrl = (chainId, tx) => {
+    return `${ChainUtils.getExplorerUrl(chainId)}/tx/${tx}`;
+  };
+  ChainUtils.CHAIN_METADATA = {
+    [1 /* EthMainnet */]: {
+      name: "Ethereum",
+      id: 1 /* EthMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://etherscan.io",
+      identifier: "mainnet"
+    },
+    [8453 /* BaseMainnet */]: {
+      name: "Base",
+      id: 8453 /* BaseMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://basescan.org",
+      identifier: "base"
+    },
+    [137 /* PolygonMainnet */]: {
+      name: "Polygon",
+      id: 137 /* PolygonMainnet */,
+      nativeCurrency: { name: "Polygon", symbol: "POL", decimals: 18 },
+      explorerUrl: "https://polygonscan.com",
+      identifier: "polygon"
+    },
+    [42161 /* ArbitrumMainnet */]: {
+      name: "Arbitrum One",
+      id: 42161 /* ArbitrumMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://arbiscan.io",
+      identifier: "arbitrum"
+    },
+    [10 /* OptimismMainnet */]: {
+      name: "OP Mainnet",
+      id: 10 /* OptimismMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://optimistic.etherscan.io",
+      identifier: "optimism"
+    },
+    [480 /* WorldChainMainnet */]: {
+      name: "World Chain",
+      id: 480 /* WorldChainMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://worldscan.org",
+      identifier: "worldchain"
+    },
+    [252 /* FraxtalMainnet */]: {
+      name: "Fraxtal",
+      id: 252 /* FraxtalMainnet */,
+      nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
+      explorerUrl: "https://fraxscan.com",
+      identifier: "fraxtal"
+    },
+    [534352 /* ScrollMainnet */]: {
+      name: "Scroll",
+      id: 534352 /* ScrollMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://scrollscan.com",
+      identifier: "scroll"
+    },
+    [57073 /* InkMainnet */]: {
+      name: "Ink",
+      id: 57073 /* InkMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://explorer.inkonchain.com",
+      identifier: "ink"
+    },
+    [130 /* UnichainMainnet */]: {
+      name: "Unichain",
+      id: 130 /* UnichainMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://uniscan.xyz",
+      identifier: "unichain"
+    },
+    [146 /* SonicMainnet */]: {
+      name: "Sonic",
+      id: 146 /* SonicMainnet */,
+      nativeCurrency: { name: "Sonic", symbol: "S", decimals: 18 },
+      explorerUrl: "https://sonicscan.org",
+      identifier: "sonic"
+    },
+    [43111 /* HemiMainnet */]: {
+      name: "Hemi",
+      id: 43111 /* HemiMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://explorer.hemi.xyz",
+      identifier: "hemi"
+    },
+    [34443 /* ModeMainnet */]: {
+      name: "Mode",
+      id: 34443 /* ModeMainnet */,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      explorerUrl: "https://modescan.io",
+      identifier: "mode"
+    },
+    [21000000 /* CornMainnet */]: {
+      name: "Corn",
+      id: 21000000 /* CornMainnet */,
+      nativeCurrency: { name: "Bitcoin", symbol: "BTCN", decimals: 18 },
+      explorerUrl: "https://cornscan.io",
+      identifier: "corn"
+    },
+    [98866 /* PlumeMainnet */]: {
+      name: "Plume",
+      id: 98866 /* PlumeMainnet */,
+      nativeCurrency: { name: "Plume", symbol: "PLUME", decimals: 18 },
+      explorerUrl: "https://phoenix-explorer.plumenetwork.xyz",
+      identifier: "plume"
+    },
+    [123420001114 /* CampMainnet */]: {
+      name: "Camp",
+      id: 123420001114 /* CampMainnet */,
+      nativeCurrency: { name: "Camp", symbol: "CAMP", decimals: 18 },
+      explorerUrl: "https://basecamp.cloud.blockscout.com/",
+      identifier: "camp"
+    },
+    [80094 /* BerachainMainnet */]: {
+      name: "Berachain",
+      id: 80094 /* BerachainMainnet */,
+      nativeCurrency: { name: "Bera", symbol: "BERA", decimals: 18 },
+      explorerUrl: "https://berascan.com/",
+      identifier: "berachain"
+    },
+    [5000 /* MantleMainnet */]: {
+      name: "Mantle",
+      id: 5000 /* MantleMainnet */,
+      nativeCurrency: { name: "Mantle", symbol: "MNT", decimals: 18 },
+      explorerUrl: "https://mantlescan.xyz/",
+      identifier: "mantle"
+    },
+    [43114 /* AvalancheMainnet */]: {
+      name: "Avalanche",
+      id: 43114 /* AvalancheMainnet */,
+      nativeCurrency: { name: "Avalanche", symbol: "AVAX", decimals: 18 },
+      explorerUrl: "https://snowtrace.io",
+      identifier: "avalanche"
+    }
+  };
+})(ChainUtils ||= {});
+
+// src/addresses.ts
+var NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var addresses = {
+  [1 /* EthMainnet */]: {
+    beaconProxyFactory: "0x09C8803f7Dc251f9FaAE5f56E3B91f8A6d0b70ee",
+    feeRegistry: "0x6dA4D1859bA1d02D095D2246142CdAd52233e27C",
+    v0_5_0: "0xe50554ec802375c9c3f9c087a8a7bb8c26d3dedf",
+    wrappedNative: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  },
+  [42161 /* ArbitrumMainnet */]: {
+    beaconProxyFactory: "0x58a7729125acA9e5E9C687018E66bfDd5b2D4490",
+    feeRegistry: "0x6dA4D1859bA1d02D095D2246142CdAd52233e27C",
+    v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf",
+    wrappedNative: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1 ",
+    dev: {
+      beaconProxyFactory: "0x29f3dba953C57814A5579e08462724B9C760333e",
+      feeRegistry: "0x45BA44B8899D39abdc383a25bB17fcD18240c6Bc"
+    }
+  },
+  [8453 /* BaseMainnet */]: {
+    beaconProxyFactory: "0xC953Fd298FdfA8Ed0D38ee73772D3e21Bf19c61b",
+    feeRegistry: "0x6dA4D1859bA1d02D095D2246142CdAd52233e27C",
+    v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf",
+    wrappedNative: "0x4200000000000000000000000000000000000006"
+  },
+  [130 /* UnichainMainnet */]: {
+    beaconProxyFactory: "0xaba1A2e157Dae248f8630cA550bd826725Ff745c",
+    feeRegistry: "0x652716FaD571f04D26a3c8fFd9E593F17123Ab20",
+    v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf",
+    wrappedNative: "0x4200000000000000000000000000000000000006"
+  },
+  [80094 /* BerachainMainnet */]: {
+    beaconProxyFactory: "0x7cf8cf276450bd568187fdc0b0959d30ec599853",
+    feeRegistry: "0xaba1A2e157Dae248f8630cA550bd826725Ff745c",
+    v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf",
+    wrappedNative: "0x6969696969696969696969696969696969696969"
+  },
+  [146 /* SonicMainnet */]: {
+    beaconProxyFactory: "0x99CD0b8b32B15922f0754Fddc21323b5278c5261",
+    feeRegistry: "0xab4aC28D10a4Bc279aD073B1D74Bfa0E385C010C",
+    v0_5_0: "0xE50554ec802375C9c3F9c087a8a7bb8C26d3DEDf",
+    wrappedNative: "0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38"
+  },
+  [5000 /* MantleMainnet */]: {
+    beaconProxyFactory: "0x57D969B556C6AebB3Ac8f54c98CF3a3f921d5659",
+    feeRegistry: "0x47A144e67834408716cB40Fa87fc886D63362ddC",
+    v0_4_0: "0xA7260Cee56B679eC05a736A7b603b8DA8525Dd69",
+    wrappedNative: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8"
+  },
+  [480 /* WorldChainMainnet */]: {
+    beaconProxyFactory: "0x600fA26581771F56221FC9847A834B3E5fd34AF7",
+    feeRegistry: "0x68e793658def657551fd4D3cA6Bc04b4E7723655",
+    v0_5_0: "0x1D42DbDde553F4099691A25F712bbd8f2686E355 ",
+    wrappedNative: "0x4200000000000000000000000000000000000006"
+  },
+  [43114 /* AvalancheMainnet */]: {
+    beaconProxyFactory: "0x5e231c6d030a5c0f51fa7d0f891d3f50a928c685",
+    feeRegistry: "0xD7F69ba99c6981Eab5579Aa16871Ae94c509d578",
+    v0_5_0: "0x33F65C8D025b5418C7f8dd248C2Ec1d31881D465",
+    wrappedNative: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7"
+  }
+};
+export {
+  resolveVersion,
+  addresses,
+  Version,
+  VaultUtils,
+  Vault,
+  Token,
+  Test,
+  State,
+  NATIVE_ADDRESS,
+  MathLib,
+  LATEST_VERSION,
+  ChainUtils,
+  ChainId
+};

package/dist/math/MathLib.d.ts

@@ -0,0 +1,103 @@
+import type { BigIntish } from "../types";
+export type RoundingDirection = "Up" | "Down";
+/**
+ * Library to manage fixed-point arithmetic.
+ * https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/MathLib.sol
+ */
+export declare namespace MathLib {
+    const WAD = 1000000000000000000n;
+    const RAY = 1000000000000000000000000000n;
+    const MAX_UINT_256: bigint;
+    const MAX_UINT_160: bigint;
+    const MAX_UINT_128: bigint;
+    const MAX_UINT_48: bigint;
+    function maxUint(nBits: number): bigint;
+    /**
+     * Returns the absolute value of a number
+     * @param a The number
+     */
+    function abs(a: BigIntish): bigint;
+    /**
+     * Returns the smallest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    function min(...xs: BigIntish[]): bigint;
+    /**
+     * Returns the greatest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    function max(...xs: BigIntish[]): bigint;
+    /**
+     * Returns the subtraction of b from a, floored to zero if negative
+     * @param x The first number
+     * @param y The second number
+     */
+    function zeroFloorSub(x: BigIntish, y: BigIntish): bigint;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded down
+     * @param x The first number
+     * @param y The second number
+     */
+    function wMulDown(x: BigIntish, y: BigIntish): bigint;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded up
+     * @param x The first number
+     * @param y The second number
+     */
+    function wMulUp(x: BigIntish, y: BigIntish): bigint;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+     * @param x The first number
+     * @param y The second number
+     */
+    function wMul(x: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
+    /**
+     * Perform the WAD-based division of 2 numbers, rounded down
+     * @param x The first number
+     * @param y The second number
+     */
+    function wDivDown(x: BigIntish, y: BigIntish): bigint;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded up
+     * @param x The first number
+     * @param y The second number
+     */
+    function wDivUp(x: BigIntish, y: BigIntish): bigint;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+     * @param x The first number
+     * @param y The second number
+     */
+    function wDiv(x: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
+    /**
+     * Multiply two numbers and divide by a denominator, rounding down the result
+     * @param x The first number
+     * @param y The second number
+     * @param denominator The denominator
+     */
+    function mulDivDown(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
+    /**
+     * Multiply two numbers and divide by a denominator, rounding up the result
+     * @param x The first number
+     * @param y The second number
+     * @param denominator The denominator
+     */
+    function mulDivUp(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
+    function mulDiv(x: BigIntish, y: BigIntish, denominator: BigIntish, rounding: RoundingDirection): bigint;
+    /**
+     * The sum of the first three non-zero terms of a Taylor expansion of e^(nx) - 1,
+     * to approximate a continuously compounded interest rate.
+     *
+     * @param x The base of the exponent
+     * @param n The exponent
+     */
+    function wTaylorCompounded(x: BigIntish, n: BigIntish): bigint;
+    /**
+     * Converts a WAD-based quantity to a RAY-based quantity.
+     * @param x The WAD-based quantity.
+     */
+    function wToRay(x: BigIntish): bigint;
+}
+//# sourceMappingURL=MathLib.d.ts.map

package/dist/math/MathLib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathLib.d.ts","sourceRoot":"","sources":["../../src/math/MathLib.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,MAAM,CAAC;AAE9C;;;GAGG;AACH,yBAAiB,OAAO,CAAC;IAChB,MAAM,GAAG,uBAAwB,CAAC;IAClC,MAAM,GAAG,gCAAiC,CAAC;IAE3C,MAAM,YAAY,QAAe,CAAC;IAClC,MAAM,YAAY,QAAe,CAAC;IAClC,MAAM,YAAY,QAAe,CAAC;IAClC,MAAM,WAAW,QAAc,CAAC;IAEvC,SAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,UAIpC;IAED;;;OAGG;IACH,SAAgB,GAAG,CAAC,CAAC,EAAE,SAAS,UAI/B;IAED;;;;OAIG;IACH,SAAgB,GAAG,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,UAErC;IAED;;;;OAIG;IACH,SAAgB,GAAG,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,UAErC;IAED;;;;OAIG;IACH,SAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,UAKtD;IAED;;;;OAIG;IACH,SAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,UAElD;IAED;;;;OAIG;IACH,SAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,UAEhD;IAED;;;;OAIG;IACH,SAAgB,IAAI,CAClB,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,EACZ,QAAQ,EAAE,iBAAiB,UAG5B;IAED;;;;OAIG;IACH,SAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,UAElD;IAED;;;;OAIG;IACH,SAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,UAEhD;IAED;;;;OAIG;IACH,SAAgB,IAAI,CAClB,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,EACZ,QAAQ,EAAE,iBAAiB,UAG5B;IAED;;;;;OAKG;IACH,SAAgB,UAAU,CACxB,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,EACZ,WAAW,EAAE,SAAS,UAQvB;IAED;;;;;OAKG;IACH,SAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,UAS1E;IAED,SAAgB,MAAM,CACpB,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,EACZ,WAAW,EAAE,SAAS,EACtB,QAAQ,EAAE,iBAAiB,UAG5B;IAED;;;;;;OAMG;IACH,SAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,UAc3D;IAED;;;OAGG;IACH,SAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,UAElC;CACF"}

package/dist/math/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MathLib";
+//# sourceMappingURL=index.d.ts.map

package/dist/math/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}

package/dist/token/Token.d.ts

@@ -0,0 +1,52 @@
+import { type RoundingDirection } from "../math/index";
+import type { Address, BigIntish } from "../types";
+export interface IToken {
+    address: Address;
+    name?: string;
+    symbol?: string;
+    decimals?: BigIntish;
+    price?: BigIntish;
+    totalSupply: bigint;
+}
+export declare class Test {
+}
+export declare class Token implements IToken {
+    /**
+     * The token's address.
+     */
+    readonly address: Address;
+    /**
+     * The token's name.
+     */
+    readonly name?: string;
+    /**
+     * The token's symbol.
+     */
+    readonly symbol?: string;
+    /**
+     * The token's number of decimals. Defaults to 0.
+     */
+    readonly decimals: number;
+    /**
+      * The vault's total supply of shares.
+      */
+    totalSupply: bigint;
+    /**
+     * Price of the token in USD (scaled by WAD).
+     */
+    price?: bigint;
+    constructor({ address, name, symbol, decimals, totalSupply, price, }: IToken);
+    /**
+     * Quotes an amount in USD (scaled by WAD) in this token.
+     * Returns `undefined` iff the token's price is undefined.
+     * @param amount The amount of USD to quote.
+     */
+    fromUsd(amount: bigint, rounding?: RoundingDirection): bigint | undefined;
+    /**
+     * Quotes an amount of tokens in USD (scaled by WAD).
+     * Returns `undefined` iff the token's price is undefined.
+     * @param amount The amount of tokens to quote.
+     */
+    toUsd(amount: bigint, rounding?: RoundingDirection): bigint | undefined;
+}
+//# sourceMappingURL=Token.d.ts.map

package/dist/token/Token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Token.d.ts","sourceRoot":"","sources":["../../src/token/Token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEnD,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,IAAI;CAAI;AAErB,qBAAa,KAAM,YAAW,MAAM;IAClC;;OAEG;IACH,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC;;OAEG;IACH,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,SAAgB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhC;;OAEG;IACH,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC;;QAEI;IACG,WAAW,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACI,KAAK,CAAC,EAAE,MAAM,CAAC;gBAGV,EACV,OAAO,EACP,IAAI,EACJ,MAAM,EACN,QAAY,EACZ,WAAW,EACX,KAAK,GACN,EAAE,MAAM;IAUT;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,iBAA0B;IAW5D;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,iBAA0B;CAU3D"}

package/dist/token/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Token";
+//# sourceMappingURL=index.d.ts.map

package/dist/token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/token/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export type BigIntish = bigint | string | number | boolean;
+export type Address = `0x${string}`;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC"}

package/dist/vault/Vault.d.ts

@@ -0,0 +1,91 @@
+import { type RoundingDirection } from "../math";
+import { type IToken, Token } from "../token/Token";
+import { type Address } from "../types";
+export declare enum Version {
+    v0_5_0 = "v0.5.0",
+    v0_4_0 = "v0.4.0",
+    v0_3_0 = "v0.3.0",
+    v0_2_0 = "v0.2.0",
+    v0_1_0 = "v0.1.0"
+}
+export declare const LATEST_VERSION = Version.v0_5_0;
+export type VersionOrLatest = Version | "latest";
+export declare function resolveVersion(version: VersionOrLatest): Version;
+export declare enum State {
+    Open = 0,
+    Closing = 1,
+    Closed = 2
+}
+export interface Rates {
+    managementRate: number;
+    performanceRate: number;
+}
+export interface IVault extends IToken {
+    asset: Address;
+    underlyingDecimals: number;
+    owner: Address;
+    pendingOwner: Address;
+    whitelistManager: Address;
+    feeReceiver: Address;
+    safe: Address;
+    feeRegistry: Address;
+    valuationManager: Address;
+    newRatesTimestamp: bigint;
+    lastFeeTime: bigint;
+    highWaterMark: bigint;
+    cooldown: bigint;
+    feeRates: Rates;
+    totalAssets: bigint;
+    newTotalAssets: bigint;
+    depositEpochId: number;
+    depositSettleId: number;
+    lastDepositEpochIdSettled: number;
+    redeemEpochId: number;
+    redeemSettleId: number;
+    lastRedeemEpochIdSettled: number;
+    pendingSilo: Address;
+    wrappedNativeToken: Address;
+    decimals: number;
+    decimalsOffset: number;
+    totalAssetsExpiration: bigint;
+    totalAssetsLifespan: bigint;
+    state: State;
+    isWhitelistActivated: boolean;
+    version: Version;
+}
+export declare class Vault extends Token implements IVault {
+    readonly asset: Address;
+    readonly underlyingDecimals: number;
+    readonly totalAssets: bigint;
+    readonly newTotalAssets: bigint;
+    readonly depositEpochId: number;
+    readonly depositSettleId: number;
+    readonly lastDepositEpochIdSettled: number;
+    readonly redeemEpochId: number;
+    readonly redeemSettleId: number;
+    readonly lastRedeemEpochIdSettled: number;
+    readonly pendingSilo: Address;
+    readonly wrappedNativeToken: Address;
+    readonly decimalsOffset: number;
+    readonly totalAssetsExpiration: bigint;
+    readonly totalAssetsLifespan: bigint;
+    readonly feeRegistry: Address;
+    readonly newRatesTimestamp: bigint;
+    readonly lastFeeTime: bigint;
+    readonly highWaterMark: bigint;
+    readonly cooldown: bigint;
+    readonly feeRates: Rates;
+    readonly owner: Address;
+    readonly pendingOwner: Address;
+    readonly whitelistManager: Address;
+    readonly feeReceiver: Address;
+    readonly safe: Address;
+    readonly valuationManager: Address;
+    readonly state: State;
+    readonly isWhitelistActivated: boolean;
+    readonly version: Version;
+    constructor({ asset, underlyingDecimals, totalAssets, newTotalAssets, depositEpochId, depositSettleId, lastDepositEpochIdSettled, redeemEpochId, redeemSettleId, lastRedeemEpochIdSettled, pendingSilo, wrappedNativeToken, decimalsOffset, totalAssetsExpiration, totalAssetsLifespan, feeRegistry, newRatesTimestamp, lastFeeTime, highWaterMark, cooldown, feeRates, owner, pendingOwner, whitelistManager, feeReceiver, safe, valuationManager, state, isWhitelistActivated, version, ...config }: IVault);
+    convertToAssets(shares: bigint, rounding?: RoundingDirection): bigint;
+    convertToShares(assets: bigint, rounding?: RoundingDirection): bigint;
+}
+//# sourceMappingURL=Vault.d.ts.map

package/dist/vault/Vault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vault.d.ts","sourceRoot":"","sources":["../../src/vault/Vault.ts"],"names":[],"mappings":"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"}

package/dist/vault/VaultUtils.d.ts

@@ -0,0 +1,18 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { BigIntish } from "../types.js";
+export declare namespace VaultUtils {
+    const VIRTUAL_ASSETS = 1n;
+    const ONE_SHARE: bigint;
+    function decimalsOffset(decimals: BigIntish): bigint;
+    function convertToAssets(shares: BigIntish, { totalAssets, totalSupply, decimalsOffset, }: {
+        totalAssets: BigIntish;
+        totalSupply: BigIntish;
+        decimalsOffset: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+    function convertToShares(assets: BigIntish, { totalAssets, totalSupply, decimalsOffset, }: {
+        totalAssets: BigIntish;
+        totalSupply: BigIntish;
+        decimalsOffset: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+}
+//# sourceMappingURL=VaultUtils.d.ts.map

package/dist/vault/VaultUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VaultUtils.d.ts","sourceRoot":"","sources":["../../src/vault/VaultUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,yBAAiB,UAAU,CAAC;IACnB,MAAM,cAAc,KAAK,CAAC;IAE1B,MAAM,SAAS,QAAa,CAAC;IAEpC,SAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,UAEjD;IAED,SAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EACjB,EACE,WAAW,EACX,WAAW,EACX,cAAc,GACf,EAAE;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,WAAW,EAAE,SAAS,CAAC;QACvB,cAAc,EAAE,SAAS,CAAC;KAC3B,EACD,QAAQ,GAAE,iBAA0B,UAQrC;IACD,SAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EACjB,EACE,WAAW,EACX,WAAW,EACX,cAAc,GACf,EAAE;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,WAAW,EAAE,SAAS,CAAC;QACvB,cAAc,EAAE,SAAS,CAAC;KAC3B,EACD,QAAQ,GAAE,iBAAwB,UAQnC;CACF"}

package/dist/vault/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Vault";
+export * from "./VaultUtils";
+//# sourceMappingURL=index.d.ts.map

package/dist/vault/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vault/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,cAAc,CAAA"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@lagoon-protocol/v0-core",
+  "description": "Framework-agnostic package that defines Lagoon related entity classes (such as Vault)",
+  "version": "0.1.2",
+  "license": "MIT",
+  "type": "module",
+  "module": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "../../LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && bun build ./src/index.ts --outdir ./dist --target node --format esm",
+    "test": "bun test",
+    "dev": "bun run --watch src/index.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "private": false,
+  "publishConfig": {
+    "tag": "next",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts"
+  }
+}