@guru-fund/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guru Fund
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# @guru-fund/sdk
+
+Quote + transaction builders for Guru Protocol managed funds.
+
+The SDK is submission-agnostic: every quote returns a `txData: TransactionRequest`
+plus a `decodeLogs(logs)` closure. You sign and broadcast yourself. Simulation
+is a caller-supplied callback so the SDK never reaches Alchemy / Tenderly /
+your provider of choice directly.
+
+## Install
+
+```sh
+npm install @guru-fund/sdk ethers
+```
+
+Peer-quality runtime deps: `ethers` (>=6.15) and `zod`. Zero internal /
+proprietary deps — the SDK is meant to be standalone-publishable.
+
+## Constructor
+
+```ts
+import { GuruProtocol } from '@guru-fund/sdk'
+
+const protocol = new GuruProtocol({
+    rpcUrl: 'https://mainnet.infura.io/v3/<key>',
+    chainId: 1, // mainnet (1) and base (8453) are supported
+})
+```
+
+`new GuruProtocol({ rpcUrl, chainId })` is the only required surface. The constructor:
+
+-   Builds an internal `JsonRpcProvider(rpcUrl)`. Do not pass a provider in.
+-   Resolves the Guru Protocol contract addresses from the SDK's vendored registry. Do
+    not pass contracts in.
+-   Throws `UnsupportedChainError` for any chain outside `{ 1, 8453 }`.
+
+Optional override slots (`GuruProtocolOptions`): `simulator`, `getSwapFeePercentage`,
+`getPriceUsd1e18`, `veloraEndpoint`, `getPath`. Each has a sensible default —
+see the no-sim pattern and the Alchemy pairing example below.
+
+## Quote methods
+
+Every quote method returns bigints natively. Stringify at your wire boundary
+if you serialize to JSON.
+
+| Method                     | Returns                                                                        |
+| -------------------------- | ------------------------------------------------------------------------------ |
+| `protocol.quoteDeposit`    | `{ sharesOutMin, extCalls, fees, referrerFeeBps, …, txData, decodeLogs }`      |
+| `protocol.quoteWithdrawal` | `{ proceeds, extCalls, routing, referrerFeeBps, …, txData, decodeLogs }`       |
+| `protocol.quoteTrade`      | `Route + txData` for one-off manager trade execution                           |
+| `protocol.quoteHarvest`    | `{ extCalls, harvestableFraction, managementFee, txData, decodeLogs }`         |
+| `protocol.quoteRebalance`  | `{ extCalls, trades, cumulativeSlippageBps, txData, decodeLogs, emptyReason }` |
+
+```ts
+const quote = await protocol.quoteDeposit({
+    ledger: '0xe93f393b987247530a94cef205070868924797e7',
+    account: '0xUserAddress',
+    coin: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+    amount: 1_000_000n, // 1 USDC (6 decimals)
+    referrerFeeBps: 0n, // see "Referrer fee policy" below
+})
+
+// 1. Submit `quote.txData` from `account`. Approvals are out-of-band.
+// 2. After execution (or sim), pipe receipt logs through quote.decodeLogs:
+const decoded = quote.decodeLogs(receipt.logs)
+//   { expectedShares: 1234n } | null
+```
+
+### Referrer fee policy
+
+`referrerFeeBps` is a required input on deposit / withdrawal. The SDK
+range-validates `0 <= referrerFeeBps <= MAX_BPS (=10_000n)` but does NOT
+derive it. Policies that depend on server-side data (governance-token
+holdings, fund composition, holdings checks) belong outside the SDK — pass
+the resolved bps in.
+
+`slippageSettings` on deposit / withdrawal / harvest / rebalance are optional
+per-token e3 slippage overrides (`"500"` = 0.5%). They become especially
+important in no-sim mode, where callers may want explicit bounds instead of
+the router defaults.
+
+## Transaction builders
+
+Static, synchronous calldata encoders. Use directly when you already know the
+deposit / withdraw / harvest shape and want a `TransactionRequest` without
+going through the quote.
+
+```ts
+const tx = GuruProtocol.buildDepositTx({
+    controller, ledger, coin, amount, sharesOutMin, extCalls,
+    referrerFeeBps, from,
+})
+GuruProtocol.buildWithdrawTx({ controller, ledger, coin, amountIn, extCalls, …, from })
+GuruProtocol.buildHarvestTx({ controller, ledger, coin, isManagementFeeEligible, extCalls, …, from })
+```
+
+The quote methods call these builders internally — single source of truth for
+calldata shape.
+
+Approvals are NOT bundled into deposit txData — handle them yourself before
+submitting the quote's `txData`.
+
+## No-sim pattern
+
+The default `simulator` callback returns `{ success: false }`, which causes
+the Velora primary router to fall through to the caller-supplied slippage
+without doing on-chain "highest-passing-amount" search. This is the
+zero-config path — quotes still work, but they are degraded for real execution
+quality because the SDK cannot validate route executability against current
+liquidity conditions.
+
+```ts
+const protocol = new GuruProtocol({ rpcUrl, chainId })
+// simulator defaults to noop — callers get caller-supplied-slippage quotes
+```
+
+## Alchemy sim pairing example
+
+Inject a custom simulator to recover the search behavior. Below uses Alchemy
+Bundle Simulation; substitute Tenderly / your own provider with the same
+callback shape.
+
+```ts
+import { GuruProtocol, type SwapSimulator } from '@guru-fund/sdk'
+import { Alchemy, Network } from 'alchemy-sdk'
+
+const alchemy = new Alchemy({
+    apiKey: process.env.ALCHEMY_API_KEY!,
+    network: Network.ETH_MAINNET,
+})
+
+const simulator: SwapSimulator = async ({
+    chainId,
+    from,
+    to,
+    callData,
+    blockNumber,
+    account,
+    amountIn,
+    tokenIn,
+}) => {
+    try {
+        const bundle = await alchemy.transact.simulateExecutionBundle(
+            [
+                // optional ERC20 prelude funding the controller
+                {
+                    from: account,
+                    to: tokenIn,
+                    value: '0x0',
+                    data: encodeApprove(to, amountIn),
+                },
+                { from, to, value: '0x0', data: callData },
+            ],
+            { blockNumber: `0x${blockNumber.toString(16)}` }
+        )
+        const target = bundle[bundle.length - 1]
+        return {
+            success: !target.error && !target.revertReason,
+            revertMessage: target.revertReason ?? target.error?.message,
+        }
+    } catch (err) {
+        return { success: false, revertMessage: String(err) }
+    }
+}
+
+const protocol = new GuruProtocol({ rpcUrl, chainId, simulator })
+```
+
+`SimulateSwapParams` and `SimulateSwapResult` are exported types — the SDK
+will only ever call your callback with the documented shape.
+
+## Custom routing
+
+By default the SDK fetches swap paths from Velora's DEX aggregator API. You might
+override this if Velora changes endpoints, you have an API key for a private
+instance, or you want to plug in a different routing backend entirely:
+
+```ts
+// Just change the endpoint
+const protocolWithCustomEndpoint = new GuruProtocol({
+    rpcUrl,
+    chainId,
+    veloraEndpoint: 'https://custom-velora.example/swap',
+})
+
+// Full custom path logic
+import type { PathFetcher } from '@guru-fund/sdk'
+
+const getPath: PathFetcher = async ({ chainId, dex, tokenIn, tokenOut }) => {
+    // your routing backend — return CachedPath or false
+}
+
+const protocolWithCustomPath = new GuruProtocol({ rpcUrl, chainId, getPath })
+```
+
+`PathFetcher`, `GetPathParams`, and `CachedPath` are exported types.
+
+## Decoding receipts
+
+`decodeLogs(logs)` is a closure baked into each quote result. It reads the
+contract event ABIs the SDK already has, so you don't have to assemble them
+yourself. Returns `null` on miss (event not present) — pair it with a
+sensible fallback in your code.
+
+```ts
+const tx = await wallet.sendTransaction(quote.txData)
+const receipt = await tx.wait()
+const decoded = quote.decodeLogs(receipt!.logs) ?? {
+    expectedShares: quote.sharesOutMin, // sensible fallback
+}
+```
+
+## Errors
+
+-   `UnsupportedChainError` — thrown by the constructor on `chainId` outside
+    `{ 1, 8453 }`.
+-   `z.ZodError` — thrown by quote methods on malformed inputs (zod schema at
+    the SDK boundary parses every quote method's input).
+-   `SdkError` — internal errors (e.g., `EVENT_NOT_FOUND` from the receipt
+    parser, `NETWORK_NOT_SUPPORTED` from the pool helper).
+-   Plain `Error` — semantic invariants like "coin is not a supported
+    stablecoin", "toll not applicable", "target weights do not sum to UNIT".
+
+## License
+
+MIT.

package/dist/GuruProtocol.d.ts

@@ -0,0 +1,44 @@
+import { type Provider } from 'ethers';
+import { type GuruProtocolAddresses, type GuruProtocolChainId } from './addresses';
+import type { GetPriceUsd1e18 } from './helpers/FundDataFetcher';
+import { type QuoteDepositParams, type QuoteDepositResult } from './quotes/quoteDeposit';
+import { type QuoteHarvestParams, type QuoteHarvestResult } from './quotes/quoteHarvest';
+import { type QuoteRebalanceParams, type QuoteRebalanceResult } from './quotes/quoteRebalance';
+import { type QuoteTradeParams, type QuoteTradeResult } from './quotes/quoteTrade';
+import { type QuoteWithdrawalParams, type QuoteWithdrawalResult } from './quotes/quoteWithdrawal';
+import { type PathFetcher } from './router/pathCache';
+import type { SwapSimulator } from './router/simulation';
+import buildDepositTx from './txBuilders/buildDepositTx';
+import buildHarvestTx from './txBuilders/buildHarvestTx';
+import buildTradeTx from './txBuilders/buildTradeTx';
+import buildWithdrawTx from './txBuilders/buildWithdrawTx';
+export interface GuruProtocolOptions {
+    rpcUrl: string;
+    chainId: number;
+    simulator?: SwapSimulator;
+    getSwapFeePercentage?: () => Promise<bigint>;
+    getPriceUsd1e18?: GetPriceUsd1e18;
+    veloraEndpoint?: string;
+    getPath?: PathFetcher;
+}
+export declare class GuruProtocol {
+    readonly chainId: GuruProtocolChainId;
+    readonly addresses: GuruProtocolAddresses;
+    readonly provider: Provider;
+    private readonly simulator;
+    private readonly getSwapFeePercentageFn;
+    private readonly getPriceUsd1e18Fn;
+    private readonly getPathFn;
+    constructor(options: GuruProtocolOptions);
+    private routerCtx;
+    quoteDeposit(params: QuoteDepositParams): Promise<QuoteDepositResult>;
+    quoteWithdrawal(params: QuoteWithdrawalParams): Promise<QuoteWithdrawalResult>;
+    quoteTrade(params: QuoteTradeParams): Promise<QuoteTradeResult>;
+    quoteHarvest(params: QuoteHarvestParams): Promise<QuoteHarvestResult>;
+    quoteRebalance(params: QuoteRebalanceParams): Promise<QuoteRebalanceResult>;
+    static buildDepositTx: typeof buildDepositTx;
+    static buildWithdrawTx: typeof buildWithdrawTx;
+    static buildHarvestTx: typeof buildHarvestTx;
+    static buildTradeTx: typeof buildTradeTx;
+}
+export default GuruProtocol;

package/dist/GuruProtocol.js

@@ -0,0 +1,75 @@
+import { JsonRpcProvider } from 'ethers';
+import { getGuruProtocolAddresses, isSupportedChainId, UnsupportedChainError, } from './addresses.js';
+import quoteDeposit from './quotes/quoteDeposit.js';
+import quoteHarvest from './quotes/quoteHarvest.js';
+import quoteRebalance from './quotes/quoteRebalance.js';
+import quoteTrade from './quotes/quoteTrade.js';
+import quoteWithdrawal from './quotes/quoteWithdrawal.js';
+import { getPriceUsd1e18 as defaultGetPriceUsd1e18 } from './router/index.js';
+import { getPath as defaultGetPath } from './router/pathCache.js';
+import buildDepositTx from './txBuilders/buildDepositTx.js';
+import buildHarvestTx from './txBuilders/buildHarvestTx.js';
+import buildTradeTx from './txBuilders/buildTradeTx.js';
+import buildWithdrawTx from './txBuilders/buildWithdrawTx.js';
+const noopSimulator = async () => ({ success: false });
+const defaultSwapFeePercentage = async () => 200n;
+export class GuruProtocol {
+    chainId;
+    addresses;
+    provider;
+    simulator;
+    getSwapFeePercentageFn;
+    getPriceUsd1e18Fn;
+    getPathFn;
+    constructor(options) {
+        if (!isSupportedChainId(options.chainId)) {
+            throw new UnsupportedChainError(options.chainId);
+        }
+        this.chainId = options.chainId;
+        this.addresses = getGuruProtocolAddresses(options.chainId);
+        this.provider = new JsonRpcProvider(options.rpcUrl);
+        this.simulator = options.simulator ?? noopSimulator;
+        this.getSwapFeePercentageFn =
+            options.getSwapFeePercentage ?? defaultSwapFeePercentage;
+        this.getPriceUsd1e18Fn =
+            options.getPriceUsd1e18 ??
+                ((token) => defaultGetPriceUsd1e18(token, {
+                    chainId: this.chainId,
+                    provider: this.provider,
+                    getSwapFeePercentage: this.getSwapFeePercentageFn,
+                }));
+        this.getPathFn =
+            options.getPath ??
+                ((params) => defaultGetPath(params, options.veloraEndpoint));
+    }
+    routerCtx() {
+        return {
+            chainId: this.chainId,
+            provider: this.provider,
+            simulator: this.simulator,
+            getSwapFeePercentage: this.getSwapFeePercentageFn,
+            getPriceUsd1e18: this.getPriceUsd1e18Fn,
+            getPath: this.getPathFn,
+        };
+    }
+    quoteDeposit(params) {
+        return quoteDeposit(params, this.routerCtx());
+    }
+    quoteWithdrawal(params) {
+        return quoteWithdrawal(params, this.routerCtx());
+    }
+    quoteTrade(params) {
+        return quoteTrade(params, this.routerCtx());
+    }
+    quoteHarvest(params) {
+        return quoteHarvest(params, this.routerCtx());
+    }
+    quoteRebalance(params) {
+        return quoteRebalance(params, this.routerCtx());
+    }
+    static buildDepositTx = buildDepositTx;
+    static buildWithdrawTx = buildWithdrawTx;
+    static buildHarvestTx = buildHarvestTx;
+    static buildTradeTx = buildTradeTx;
+}
+export default GuruProtocol;

package/dist/addresses.d.ts

@@ -0,0 +1,40 @@
+export type GuruProtocolChainId = 1 | 8453;
+type AdapterKey = 'uniswapV2' | 'uniswapV3' | 'uniswapV4' | 'uniswapV4Hook' | 'pancakeV2' | 'pancakeV3' | 'aerodromeV2' | 'aerodromeV3';
+type FactoryKey = AdapterKey | 'aerodromeV3Bis';
+type RouterKey = AdapterKey;
+type QuoterKey = 'uniswapV3' | 'uniswapV4' | 'pancakeV3' | 'aerodromeV3';
+export type GuruProtocolAddresses = {
+    readonly chainId: GuruProtocolChainId;
+    readonly protocol: string;
+    readonly vaultImplementation: string;
+    readonly ledgerImplementation: string;
+    readonly controllers: Readonly<Partial<{
+        creation: string;
+        deposit: string;
+        withdrawal: string;
+        closure: string;
+        harvest: string;
+        transfer: string;
+        trade: string;
+        fund: string;
+    }>>;
+    readonly adapters: Readonly<Partial<Record<AdapterKey, string>>>;
+    readonly factories: Readonly<Partial<Record<FactoryKey, string>>>;
+    readonly routers: Readonly<Partial<Record<RouterKey, string>>>;
+    readonly quoters: Readonly<Partial<Record<QuoterKey, string>>>;
+    readonly tokens: Readonly<{
+        WETH: string;
+        USDC: string;
+        USDT: string;
+    }>;
+    readonly migrator?: string;
+};
+export declare class UnsupportedChainError extends Error {
+    readonly chainId: number;
+    constructor(chainId: number);
+}
+export declare const GURU_PROTOCOL_ADDRESSES: Readonly<Record<GuruProtocolChainId, GuruProtocolAddresses>>;
+export declare const SUPPORTED_CHAIN_IDS: readonly GuruProtocolChainId[];
+export declare const isSupportedChainId: (chainId: number) => chainId is GuruProtocolChainId;
+export declare function getGuruProtocolAddresses(chainId: number): GuruProtocolAddresses;
+export {};

package/dist/addresses.js

@@ -0,0 +1,111 @@
+export class UnsupportedChainError extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`[@guru-fund/sdk] chainId ${chainId} is not supported. Supported chainIds: ${SUPPORTED_CHAIN_IDS.join(', ')}`);
+        this.name = 'UnsupportedChainError';
+        this.chainId = chainId;
+    }
+}
+const MAINNET = {
+    chainId: 1,
+    protocol: '0x63d990618fe7f763b08a47d0295ba06207dc6b38',
+    vaultImplementation: '0x7a4087200216198482de0270998a9571813db300',
+    ledgerImplementation: '0xe52160f5f90c6bd910c9ef106911185445cdaf15',
+    controllers: {
+        creation: '0x1eecd3e1832a3a9abb618df8ee1900a6e7101cff',
+        deposit: '0x75aa804a208057b5d692cd213d39591a952a2aba',
+        withdrawal: '0x15da4363b3729c6f2befebd6f87d84bd8747dcce',
+        closure: '0x54ef8309cae3c5b134f864f9a582be8d87e488b3',
+        harvest: '0x81d60af23a90101e844fa8c919fb98a0ff1f8787',
+        transfer: '0x08377d07e09248a897695cc7286d26a4bf07e02f',
+        trade: '0x6912fa7cd7f15bdcab4c5dc5268025fb1b1d6aa8',
+        fund: '0xf9357a85e79c388c13fb83b237ff759675cc5977',
+    },
+    adapters: {
+        uniswapV2: '0xa8ddce8dbd35c65cf1de5d3be0df0e34e4c7edc2',
+        uniswapV3: '0xefccd55c1c4a471d72f37f84d65361ed708d22d7',
+        uniswapV4: '0xc53089118e3e988929a09286f73491bbca174fcb',
+        uniswapV4Hook: '0x8f6cba5d0ccda93ffd16b7c367a78f0d1f0fa374',
+        pancakeV2: '0x0dd3d063146a53878d25f6463d6347f8cd7a0629',
+        pancakeV3: '0x6eaa8a505f5d18563ef6881a4fd7811f4b6b9dca',
+    },
+    factories: {
+        uniswapV2: '0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f',
+        uniswapV3: '0x1f98431c8ad98523631ae4a59f267346ea31f984',
+        pancakeV2: '0x1097053fd2ea711dad45caccc45eff7548fcb362',
+        pancakeV3: '0x0bfbcf9fa4f9c56b0f40a671ad40e0805a091865',
+    },
+    routers: {
+        uniswapV2: '0x7a250d5630b4cf539739df2c5dacb4c659f2488d',
+        uniswapV3: '0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45',
+        pancakeV2: '0xeff92a263d31888d860bd50809a8d171709b7b1c',
+        pancakeV3: '0x1b81d678ffb9c0263b24a97847620c99d213eb14',
+    },
+    quoters: {
+        uniswapV3: '0x61ffe014ba17989e743c5f6cb21bf9697530b21e',
+        uniswapV4: '0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203',
+        pancakeV3: '0xb048bbc1ee6b733fffcfb9e9cef7375518e25997',
+    },
+    tokens: {
+        WETH: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+        USDC: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+        USDT: '0xdac17f958d2ee523a2206206994597c13d831ec7',
+    },
+    migrator: '0x616397d1e372023b5ac0498eeed2fd9fc9c06a79',
+};
+const BASE = {
+    chainId: 8453,
+    protocol: '0x7a4087200216198482de0270998a9571813db300',
+    vaultImplementation: '0xe52160f5f90c6bd910c9ef106911185445cdaf15',
+    ledgerImplementation: '0x1eecd3e1832a3a9abb618df8ee1900a6e7101cff',
+    controllers: {
+        fund: '0x70451b00c42a73ea2d9707ddc7413aff8620be85',
+    },
+    adapters: {
+        aerodromeV2: '0x581aa0ea01387e1b85d8bc3e14ec3475dee9c334',
+        aerodromeV3: '0x3d95d6cf7f41c905ec132020d3a39898a20977ae',
+        pancakeV3: '0x2d993c905426994a7dbb7115ca460ef33e384906',
+        uniswapV2: '0xefccd55c1c4a471d72f37f84d65361ed708d22d7',
+        uniswapV3: '0x0dd3d063146a53878d25f6463d6347f8cd7a0629',
+        uniswapV4: '0xe227ed4c09003a875432147379c334ce02c4d229',
+    },
+    factories: {
+        aerodromeV2: '0x420dd381b31aef6683db6b902084cb0ffece40da',
+        aerodromeV3: '0x5e7bb104d84c7cb9b682aac2f3d509f5f406809a',
+        aerodromeV3Bis: '0x9592cd9b267748cbfbde90ac9f7df3c437a6d51b',
+        uniswapV2: '0x8909dc15e40173ff4699343b6eb8132c65e18ec6',
+        uniswapV3: '0x33128a8fc17869897dce68ed026d694621f6fdfd',
+        pancakeV3: '0x0bfbcf9fa4f9c56b0f40a671ad40e0805a091865',
+    },
+    routers: {
+        aerodromeV2: '0xcf77a3ba9a5ca399b7c97c74d54e5b1beb874e43',
+        aerodromeV3: '0xbe6d8f0d05cc4be24d5167a3ef062215be6d18a5',
+        uniswapV2: '0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24',
+        uniswapV3: '0x2626664c2603336e57b271c5c0b26f421741e481',
+    },
+    quoters: {
+        aerodromeV3: '0x254cf9e1e6e233aa1ac962cb9b05b2cfeaae15b0',
+        uniswapV3: '0x3d4e44eb1374240ce5f1b871ab261cd16335b76a',
+        uniswapV4: '0x0d5e0f971ed27fbff6c2837bf31316121532048d',
+    },
+    tokens: {
+        WETH: '0x4200000000000000000000000000000000000006',
+        USDC: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+        USDT: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
+    },
+    migrator: '0x209656784c8eb405765288c8f447d11c0aa1a3d3',
+};
+export const GURU_PROTOCOL_ADDRESSES = {
+    1: MAINNET,
+    8453: BASE,
+};
+export const SUPPORTED_CHAIN_IDS = [
+    1, 8453,
+];
+export const isSupportedChainId = (chainId) => chainId === 1 || chainId === 8453;
+export function getGuruProtocolAddresses(chainId) {
+    if (!isSupportedChainId(chainId)) {
+        throw new UnsupportedChainError(chainId);
+    }
+    return GURU_PROTOCOL_ADDRESSES[chainId];
+}

package/dist/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const DEFAULT_MANAGER_FEE_RATIO: bigint;
+export declare const TOLL_DIVISOR_20BPS = 500n;
+export declare const TOLL_DIVISOR_30BPS = 333n;
+export declare const TOLL_DIVISOR_40BPS = 250n;
+export declare const TOLL_DIVISOR_50BPS = 200n;
+export declare const DEPOSIT_FEE_DIVISOR = 100n;
+export declare const DEPOSIT_DISCOUNTED_FEE_DIVISOR = 200n;
+export declare const SECONDS_PER_YEAR = 31536000n;
+export declare const MAX_BPS = 10000n;
+export declare const MANAGEMENT_FEE_DIVISOR_NUMERATOR: bigint;
+export declare const MANAGEMENT_FEE_DIVISOR_2 = 1576800000n;
+export declare const MANAGEMENT_FEE_DIVISOR_3 = 1051200000n;
+export declare const MANAGEMENT_FEE_DIVISOR_4 = 788400000n;
+export declare enum ManagementFee {
+    TWO_PERCENT = 0,
+    THREE_PERCENT = 1,
+    FOUR_PERCENT = 2
+}
+export declare const MANAGEMENT_FEE_COOLDOWN_DAYS = 30n;
+export declare const MANAGEMENT_FEE_ELIGIBLE_GOVERNANCE_TOKEN_RATIO: bigint;
+export declare const GURU_TOKEN_MAINNET = "0xaa7d24c3e14491abac746a98751a4883e9b70843";
+export declare const UNIT: bigint;

package/dist/constants.js

@@ -0,0 +1,23 @@
+export const DEFAULT_MANAGER_FEE_RATIO = BigInt(0.1e18);
+export const TOLL_DIVISOR_20BPS = 500n;
+export const TOLL_DIVISOR_30BPS = 333n;
+export const TOLL_DIVISOR_40BPS = 250n;
+export const TOLL_DIVISOR_50BPS = 200n;
+export const DEPOSIT_FEE_DIVISOR = 100n;
+export const DEPOSIT_DISCOUNTED_FEE_DIVISOR = 200n;
+export const SECONDS_PER_YEAR = 31536000n;
+export const MAX_BPS = 10000n;
+export const MANAGEMENT_FEE_DIVISOR_NUMERATOR = 100n * SECONDS_PER_YEAR;
+export const MANAGEMENT_FEE_DIVISOR_2 = 1576800000n;
+export const MANAGEMENT_FEE_DIVISOR_3 = 1051200000n;
+export const MANAGEMENT_FEE_DIVISOR_4 = 788400000n;
+export var ManagementFee;
+(function (ManagementFee) {
+    ManagementFee[ManagementFee["TWO_PERCENT"] = 0] = "TWO_PERCENT";
+    ManagementFee[ManagementFee["THREE_PERCENT"] = 1] = "THREE_PERCENT";
+    ManagementFee[ManagementFee["FOUR_PERCENT"] = 2] = "FOUR_PERCENT";
+})(ManagementFee || (ManagementFee = {}));
+export const MANAGEMENT_FEE_COOLDOWN_DAYS = 30n;
+export const MANAGEMENT_FEE_ELIGIBLE_GOVERNANCE_TOKEN_RATIO = BigInt(0.05e18);
+export const GURU_TOKEN_MAINNET = '0xaa7d24c3e14491abac746a98751a4883e9b70843';
+export const UNIT = BigInt(1e18);

package/dist/helpers/FundDataFetcher.d.ts

@@ -0,0 +1,24 @@
+import { Provider } from 'ethers';
+import { Fund } from '../types/Fund';
+export interface FundLedgerReadMethods {
+    balanceOf(account: string): Promise<bigint>;
+    decimals(): Promise<bigint>;
+    epochFeePerShare(price: bigint): Promise<bigint>;
+    getAssets(): Promise<string[]>;
+    totalSupply(): Promise<bigint>;
+    vault(): Promise<string>;
+}
+export type GetPriceUsd1e18 = (token: string) => Promise<bigint>;
+export type FundDataFetcherConfig = {
+    chainId: number;
+    provider: Provider;
+    getPriceUsd1e18: GetPriceUsd1e18;
+};
+export declare const WEIGHT_DENOMINATOR = 100000n;
+export default class FundDataFetcher {
+    private provider;
+    private getPriceUsd1e18;
+    constructor(config: FundDataFetcherConfig);
+    getUserTvlShare(ledger: FundLedgerReadMethods, account: string, tokenValue: bigint): Promise<bigint>;
+    fetchFundData(ledger: FundLedgerReadMethods): Promise<Fund.Overview>;
+}

package/dist/helpers/FundDataFetcher.js

@@ -0,0 +1,66 @@
+import { UNIT } from '../constants.js';
+import { Token } from './Token.js';
+export const WEIGHT_DENOMINATOR = 100000n;
+export default class FundDataFetcher {
+    provider;
+    getPriceUsd1e18;
+    constructor(config) {
+        this.provider = config.provider;
+        this.getPriceUsd1e18 = config.getPriceUsd1e18;
+    }
+    async getUserTvlShare(ledger, account, tokenValue) {
+        const [userBalance, decimals] = await Promise.all([
+            ledger.balanceOf(account),
+            ledger.decimals(),
+        ]);
+        const unit = 10n ** decimals;
+        return (userBalance * tokenValue) / unit;
+    }
+    async fetchFundData(ledger) {
+        const [vault, assetAddresses, tokenTotalSupply] = await Promise.all([
+            ledger.vault(),
+            ledger.getAssets().then((a) => a.map((a) => a.toLowerCase())),
+            ledger.totalSupply(),
+        ]);
+        const mapAssetValue = (values) => Object.fromEntries(values.map((value, index) => [assetAddresses[index], value]));
+        const [tokensByAddress, balancesByAddress, pricesByAddress] = await Promise.all([
+            Promise.all(assetAddresses.map((address) => new Token(address, this.provider).metadata())).then(mapAssetValue),
+            Promise.all(assetAddresses.map((address) => new Token(address, this.provider).balanceOf(vault))).then(mapAssetValue),
+            Promise.all(assetAddresses.map((address) => this.getPriceUsd1e18(address))).then(mapAssetValue),
+        ]);
+        const assets = assetAddresses.map((address, index) => {
+            const token = tokensByAddress[address];
+            const balance = balancesByAddress[address];
+            const usd1e18Price = pricesByAddress[address];
+            const totalUsd1e18Value = (usd1e18Price * balance) / Token.unitFor(token.decimals);
+            return {
+                index,
+                token,
+                balance,
+                usd1e18Price,
+                totalUsd1e18Value,
+                weight: 0n,
+                depositWeight: 0n,
+            };
+        });
+        const totalValueLocked = assets.reduce((total, asset) => total + asset.totalUsd1e18Value, 0n);
+        const tokenPrice = tokenTotalSupply === 0n
+            ? 0n
+            : (totalValueLocked * UNIT) / tokenTotalSupply;
+        const tokenValue = tokenPrice - (await ledger.epochFeePerShare(tokenPrice));
+        const assetsWithWeights = assets.map(({ totalUsd1e18Value, ...asset }) => ({
+            ...asset,
+            weight: totalValueLocked === 0n
+                ? 0n
+                : (totalUsd1e18Value * WEIGHT_DENOMINATOR) /
+                    totalValueLocked,
+        }));
+        return {
+            assets: assetsWithWeights,
+            tokenTotalSupply,
+            totalValueLocked,
+            tokenValue,
+            tokenPrice,
+        };
+    }
+}