@guru-fund/sdk 0.1.0

package/dist/helpers/ReceiptParser.d.ts

@@ -0,0 +1,23 @@
+import { ContractTransactionReceipt, Interface } from 'ethers';
+import { TypedContractEvent } from '../typechain/common';
+type TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+export default class ReceiptParser {
+    private receipt;
+    constructor(receipt: ContractTransactionReceipt);
+    static fromSimulationLogs(logs: {
+        address: string;
+        data: string;
+        topics: string[];
+    }[]): ReceiptParser;
+    getDecodedLog<T extends TypedContractEvent>(contractInterface: Interface, typedContractEvent: T): TypechainOutputObject<T>;
+    getDecodedLogAndEmitter<T extends TypedContractEvent>(contractInterface: Interface, typedContractEvent: T): {
+        emitter: string;
+        decodedLog: TypechainOutputObject<T>;
+    };
+    getDecodedLogs<T extends TypedContractEvent>(contractInterface: Interface, typedContractEvent: T): TypechainOutputObject<T>[];
+    getDecodedLogsAndEmitters<T extends TypedContractEvent>(contractInterface: Interface, typedContractEvent: T): {
+        emitter: string;
+        decodedLog: TypechainOutputObject<T>;
+    }[];
+}
+export {};

package/dist/helpers/ReceiptParser.js

@@ -0,0 +1,59 @@
+export default class ReceiptParser {
+    receipt;
+    constructor(receipt) {
+        this.receipt = receipt;
+    }
+    static fromSimulationLogs(logs) {
+        const padded = logs.map((l) => ({
+            ...l,
+            topics: l.topics.map((t) => t.length < 66 ? '0x' + t.slice(2).padStart(64, '0') : t),
+        }));
+        return new ReceiptParser({
+            logs: padded,
+        });
+    }
+    getDecodedLog(contractInterface, typedContractEvent) {
+        for (const log of this.receipt.logs) {
+            const parsedLog = contractInterface.parseLog(log);
+            if (parsedLog?.name === typedContractEvent.name) {
+                return parsedLog.args.toObject(true);
+            }
+        }
+        throw new Error(`Event ${typedContractEvent.name} not found`);
+    }
+    getDecodedLogAndEmitter(contractInterface, typedContractEvent) {
+        for (const log of this.receipt.logs) {
+            const parsedLog = contractInterface.parseLog(log);
+            if (parsedLog?.name === typedContractEvent.name) {
+                return {
+                    emitter: log.address,
+                    decodedLog: parsedLog.args.toObject(true),
+                };
+            }
+        }
+        throw new Error(`Event ${typedContractEvent.name} not found`);
+    }
+    getDecodedLogs(contractInterface, typedContractEvent) {
+        const logs = [];
+        for (const log of this.receipt.logs) {
+            const parsedLog = contractInterface.parseLog(log);
+            if (parsedLog?.name === typedContractEvent.name) {
+                logs.push(parsedLog.args.toObject(true));
+            }
+        }
+        return logs;
+    }
+    getDecodedLogsAndEmitters(contractInterface, typedContractEvent) {
+        const logs = [];
+        for (const log of this.receipt.logs) {
+            const parsedLog = contractInterface.parseLog(log);
+            if (parsedLog?.name === typedContractEvent.name) {
+                logs.push({
+                    emitter: log.address,
+                    decodedLog: parsedLog.args.toObject(true),
+                });
+            }
+        }
+        return logs;
+    }
+}

package/dist/helpers/Token.d.ts

@@ -0,0 +1,18 @@
+import { Interface, type Provider } from 'ethers';
+export interface TokenMetadata {
+    address: string;
+    decimals: number;
+    symbol: string;
+    name: string;
+}
+export declare class Token {
+    readonly address: string;
+    static readonly interface: Interface;
+    static unitFor(decimals: number): bigint;
+    static format(amount: bigint, decimals: number): string;
+    private readonly contract;
+    constructor(address: string, provider: Provider);
+    metadata(): Promise<TokenMetadata>;
+    balanceOf(account: string): Promise<bigint>;
+    allowance(owner: string, spender: string): Promise<bigint>;
+}

package/dist/helpers/Token.js

@@ -0,0 +1,43 @@
+import { Contract, formatUnits, Interface } from 'ethers';
+const ERC20_ABI = [
+    'function decimals() view returns (uint8)',
+    'function symbol() view returns (string)',
+    'function name() view returns (string)',
+    'function balanceOf(address) view returns (uint256)',
+    'function allowance(address,address) view returns (uint256)',
+    'function approve(address spender, uint256 amount) returns (bool)',
+];
+export class Token {
+    address;
+    static interface = new Interface(ERC20_ABI);
+    static unitFor(decimals) {
+        return 10n ** BigInt(decimals);
+    }
+    static format(amount, decimals) {
+        return formatUnits(amount, decimals);
+    }
+    contract;
+    constructor(address, provider) {
+        this.address = address;
+        this.contract = new Contract(address, ERC20_ABI, provider);
+    }
+    async metadata() {
+        const [decimals, symbol, name] = await Promise.all([
+            this.contract.decimals(),
+            this.contract.symbol(),
+            this.contract.name(),
+        ]);
+        return {
+            address: this.address,
+            decimals: Number(decimals),
+            symbol,
+            name,
+        };
+    }
+    balanceOf(account) {
+        return this.contract.balanceOf(account);
+    }
+    allowance(owner, spender) {
+        return this.contract.allowance(owner, spender);
+    }
+}

package/dist/helpers/compareAddresses.d.ts

@@ -0,0 +1 @@
+export default function compareAddresses(a: string, b: string): boolean;

package/dist/helpers/compareAddresses.js

@@ -0,0 +1,15 @@
+export default function compareAddresses(a, b) {
+    if (!a.match(/^0x[0-9a-fA-F]{40}$/) || !b.match(/^0x[0-9a-fA-F]{40}$/)) {
+        console.error('Invalid address');
+        console.table({
+            A: {
+                Address: a,
+            },
+            B: {
+                Address: b,
+            },
+        });
+        throw new Error('Invalid address');
+    }
+    return a.toLowerCase() === b.toLowerCase();
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { default as ReceiptParser } from './helpers/ReceiptParser';
+export { GURU_PROTOCOL_ADDRESSES, SUPPORTED_CHAIN_IDS, UnsupportedChainError, getGuruProtocolAddresses, isSupportedChainId, } from './addresses';
+export type { GuruProtocolAddresses, GuruProtocolChainId } from './addresses';
+export { GuruProtocol } from './GuruProtocol';
+export type { GuruProtocolOptions } from './GuruProtocol';
+export type { BuildDepositTxParams, BuildHarvestTxParams, BuildTradeTxParams, BuildWithdrawTxParams, } from './txBuilders';
+export type { QuoteDepositParams, QuoteDepositResult, QuoteDepositLogs, } from './quotes/quoteDeposit';
+export type { QuoteWithdrawalParams, QuoteWithdrawalResult, QuoteWithdrawalLogs, } from './quotes/quoteWithdrawal';
+export type { QuoteTradeParams, QuoteTradeResult } from './quotes/quoteTrade';
+export type { QuoteHarvestParams, QuoteHarvestResult, QuoteHarvestLogs, } from './quotes/quoteHarvest';
+export type { QuoteRebalanceParams, QuoteRebalanceResult, QuoteRebalanceLogs, QuoteRebalanceTrade, QuoteRebalanceLogTrade, QuoteRebalanceEmptyReason, QuoteRebalanceTargetWeight, } from './quotes/quoteRebalance';
+export type { Route, RouteSearchParams, V2Path, V3Path, V3PathHop, CachedPath, } from './router/types';
+export type { PathFetcher, GetPathParams } from './router/pathCache';
+export type { PrefixTx, SwapSimulator, SimulateSwapParams, SimulateSwapResult, } from './router/simulation';
+export type { ExternalCallStruct } from './quotes/quoteRebalance';
+export type { Fund } from './types/Fund';
+export type { TransactionRequest } from 'ethers';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { default as ReceiptParser } from './helpers/ReceiptParser.js';
+export { GURU_PROTOCOL_ADDRESSES, SUPPORTED_CHAIN_IDS, UnsupportedChainError, getGuruProtocolAddresses, isSupportedChainId, } from './addresses.js';
+export { GuruProtocol } from './GuruProtocol.js';

package/dist/quotes/quoteDeposit.d.ts

@@ -0,0 +1,41 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+import type { GuruProtocolChainId } from '../addresses';
+import { type GetPriceUsd1e18 } from '../helpers/FundDataFetcher';
+import { type RouterContext } from '../router';
+import type { Fund } from '../types/Fund';
+export type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface QuoteDepositParams {
+    ledger: string;
+    account: string;
+    coin: string;
+    amount: bigint;
+    referrerFeeBps: bigint;
+    slippageSettings?: Record<string, string | number | bigint>;
+}
+export interface QuoteDepositContext extends RouterContext {
+    chainId: GuruProtocolChainId;
+    getPriceUsd1e18: GetPriceUsd1e18;
+}
+export interface QuoteDepositLogs {
+    expectedShares: bigint;
+}
+export type SimulationLog = {
+    address: string;
+    data: string;
+    topics: string[];
+};
+export interface QuoteDepositResult {
+    sharesOutMin: bigint;
+    extCalls: ExternalCallStruct[];
+    fees: bigint;
+    referrerFeeBps: bigint;
+    cumulativeSlippageBps: bigint;
+    perAssetSlippageBps: Record<string, bigint>;
+    txData: TransactionRequest;
+    decodeLogs: (logs: SimulationLog[]) => QuoteDepositLogs | null;
+}
+export declare function allocateDepositInputAmounts(assets: Fund.Asset[], totalAmount: bigint, totalValueLocked: bigint): Map<string, bigint>;
+export default function quoteDeposit(params: QuoteDepositParams, ctx: QuoteDepositContext): Promise<QuoteDepositResult>;

package/dist/quotes/quoteDeposit.js

@@ -0,0 +1,186 @@
+import { MAX_BPS, UNIT } from '../constants.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import FundDataFetcher, { WEIGHT_DENOMINATOR, } from '../helpers/FundDataFetcher.js';
+import ReceiptParser from '../helpers/ReceiptParser.js';
+import { Token } from '../helpers/Token.js';
+import { getRouteIn } from '../router/index.js';
+import { quoteDepositSchema } from '../schemas/quoteDeposit.js';
+import buildDepositTx from '../txBuilders/buildDepositTx.js';
+import { FundLedger__factory } from '../typechain/index.js';
+const MAX_UINT256 = (1n << 256n) - 1n;
+const minBigint = (a, b) => (a < b ? a : b);
+const slippageE2For = (settings, token) => {
+    const slippage = settings?.[token.toLowerCase()];
+    return slippage == null ? undefined : Number(BigInt(slippage) / 10n);
+};
+const assetUsd1e18Value = (asset) => (asset.usd1e18Price * asset.balance) / Token.unitFor(asset.token.decimals);
+export function allocateDepositInputAmounts(assets, totalAmount, totalValueLocked) {
+    const allocations = new Map();
+    if (totalAmount === 0n || totalValueLocked === 0n) {
+        for (const asset of assets) {
+            allocations.set(asset.token.address.toLowerCase(), 0n);
+        }
+        return allocations;
+    }
+    const weighted = assets.map((asset) => {
+        const usdValue = assetUsd1e18Value(asset);
+        const weightedAmount = totalAmount * usdValue;
+        const amount = weightedAmount / totalValueLocked;
+        return {
+            asset,
+            amount,
+            remainder: weightedAmount % totalValueLocked,
+        };
+    });
+    const allocated = weighted.reduce((sum, item) => sum + item.amount, 0n);
+    let remainder = totalAmount - allocated;
+    weighted
+        .sort((a, b) => a.remainder === b.remainder ? 0 : a.remainder > b.remainder ? -1 : 1)
+        .forEach((item) => {
+        const extra = remainder > 0n ? 1n : 0n;
+        allocations.set(item.asset.token.address.toLowerCase(), item.amount + extra);
+        remainder -= extra;
+    });
+    return allocations;
+}
+export default async function quoteDeposit(params, ctx) {
+    const parsed = quoteDepositSchema.parse(params);
+    if (parsed.referrerFeeBps < 0n || parsed.referrerFeeBps > MAX_BPS) {
+        throw new Error(`referrerFeeBps must be between 0 and ${MAX_BPS}, got ${parsed.referrerFeeBps}`);
+    }
+    const provider = ctx.provider;
+    const ledger = FundLedger__factory.connect(parsed.ledger, provider);
+    const fetcher = new FundDataFetcher({
+        chainId: ctx.chainId,
+        provider,
+        getPriceUsd1e18: ctx.getPriceUsd1e18,
+    });
+    const [fundData, vault, controllerAddress] = await Promise.all([
+        fetcher.fetchFundData(ledger),
+        ledger.vault(),
+        ledger.controller(),
+    ]);
+    const referrerFeeBps = parsed.referrerFeeBps;
+    const originalAmount = parsed.amount;
+    let fees = (originalAmount * referrerFeeBps) / MAX_BPS;
+    const adjustedAmount = originalAmount - fees;
+    const coinData = fundData.assets.find((asset) => compareAddresses(asset.token.address, parsed.coin));
+    const inputAllocations = allocateDepositInputAmounts(fundData.assets, adjustedAmount, fundData.totalValueLocked);
+    const coinInputAmount = coinData
+        ? (inputAllocations.get(coinData.token.address.toLowerCase()) ?? 0n)
+        : 0n;
+    if (coinData && coinData.balance > 0n && coinInputAmount === 0n) {
+        throw new Error(`Deposit amount is too small to allocate input for asset ${coinData.token.address}`);
+    }
+    let lowestInputRatio = coinData && coinData.balance > 0n
+        ? (coinInputAmount * UNIT) / coinData.balance
+        : MAX_UINT256;
+    const assetsToSwap = fundData.assets.filter((asset) => !compareAddresses(asset.token.address, parsed.coin));
+    const routeResults = await Promise.all(assetsToSwap.map(async (asset) => {
+        const amountIn = inputAllocations.get(asset.token.address.toLowerCase()) ?? 0n;
+        if (asset.balance > 0n && amountIn === 0n) {
+            throw new Error(`Deposit amount is too small to allocate input for asset ${asset.token.address}`);
+        }
+        const route = await getRouteIn({
+            chainId: ctx.chainId,
+            tokenIn: parsed.coin,
+            tokenOut: asset.token.address,
+            amountIn,
+            account: parsed.account,
+            vault,
+        }, ctx);
+        return { asset, route };
+    }));
+    const coinToken = await new Token(parsed.coin, provider).metadata();
+    const coinUsd1e18Price = await ctx.getPriceUsd1e18(parsed.coin);
+    const externalTokenMetadata = new Map();
+    const externalUsd1e18Prices = new Map();
+    const getTokenMetadata = async (address) => {
+        const existingAsset = fundData.assets.find((asset) => compareAddresses(asset.token.address, address));
+        if (existingAsset)
+            return existingAsset.token;
+        const key = address.toLowerCase();
+        const cached = externalTokenMetadata.get(key);
+        if (cached)
+            return cached;
+        const metadata = await new Token(address, provider).metadata();
+        externalTokenMetadata.set(key, metadata);
+        return metadata;
+    };
+    const getUsd1e18Price = async (address) => {
+        const existingAsset = fundData.assets.find((asset) => compareAddresses(asset.token.address, address));
+        if (existingAsset)
+            return existingAsset.usd1e18Price;
+        const key = address.toLowerCase();
+        const cached = externalUsd1e18Prices.get(key);
+        if (cached != null)
+            return cached;
+        const price = await ctx.getPriceUsd1e18(address);
+        externalUsd1e18Prices.set(key, price);
+        return price;
+    };
+    const tollToCoinUnits = async (amount, currency) => {
+        const currencyAddress = String(currency);
+        if (amount === 0n || compareAddresses(currencyAddress, parsed.coin)) {
+            return amount;
+        }
+        if (coinUsd1e18Price === 0n)
+            return 0n;
+        const [tollToken, tollUsd1e18Price] = await Promise.all([
+            getTokenMetadata(currencyAddress),
+            getUsd1e18Price(currencyAddress),
+        ]);
+        const tollUsd1e18 = (amount * tollUsd1e18Price) / Token.unitFor(tollToken.decimals);
+        return ((tollUsd1e18 * Token.unitFor(coinToken.decimals)) / coinUsd1e18Price);
+    };
+    const extCalls = [];
+    const perAssetSlippageBps = {};
+    let cumulativeSlippageBps = 0n;
+    for (const { asset, route } of routeResults) {
+        extCalls.push({
+            adapter: route.adapter,
+            callData: route.callData,
+        });
+        fees += await tollToCoinUnits(route.toll.amount, route.toll.currency);
+        lowestInputRatio = minBigint(lowestInputRatio, (BigInt(route.data.amountToReceive) * UNIT) / asset.balance);
+        const bps = route.effectiveSlippageBps;
+        if (bps != null) {
+            const bpsN = BigInt(bps);
+            const assetKey = asset.token.address.toLowerCase();
+            perAssetSlippageBps[assetKey] = bpsN;
+            cumulativeSlippageBps += (bpsN * asset.weight) / WEIGHT_DENOMINATOR;
+        }
+    }
+    const sharesOutMin = (fundData.tokenTotalSupply * lowestInputRatio) / UNIT;
+    const txData = buildDepositTx({
+        controller: controllerAddress,
+        ledger: parsed.ledger,
+        coin: parsed.coin,
+        amount: originalAmount,
+        sharesOutMin,
+        extCalls,
+        referrerFeeBps,
+        from: parsed.account,
+    });
+    const depositedEvent = ledger.getEvent('Deposited');
+    const decodeLogs = (logs) => {
+        try {
+            const parser = ReceiptParser.fromSimulationLogs(logs);
+            const deposited = parser.getDecodedLog(ledger.interface, depositedEvent);
+            return { expectedShares: deposited.shares };
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        sharesOutMin,
+        extCalls,
+        fees,
+        referrerFeeBps,
+        cumulativeSlippageBps,
+        perAssetSlippageBps,
+        txData,
+        decodeLogs,
+    };
+}

package/dist/quotes/quoteHarvest.d.ts

@@ -0,0 +1,34 @@
+import { type AddressLike, type BytesLike, type TransactionRequest } from 'ethers';
+import { type GuruProtocolChainId } from '../addresses';
+import { type GetPriceUsd1e18 } from '../helpers/FundDataFetcher';
+import { type RouterContext } from '../router';
+export type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface QuoteHarvestParams {
+    ledger: string;
+    coin: string;
+    isManagementFeeEligible?: boolean;
+    slippageSettings?: Record<string, bigint>;
+}
+export interface QuoteHarvestContext extends RouterContext {
+    chainId: GuruProtocolChainId;
+    getPriceUsd1e18: GetPriceUsd1e18;
+}
+export interface QuoteHarvestLogs {
+    harvestableAmount: bigint;
+}
+export type SimulationLog = {
+    address: string;
+    data: string;
+    topics: string[];
+};
+export interface QuoteHarvestResult {
+    extCalls: ExternalCallStruct[];
+    harvestableFraction: bigint;
+    managementFee: bigint;
+    txData: TransactionRequest;
+    decodeLogs: (logs: SimulationLog[]) => QuoteHarvestLogs | null;
+}
+export default function quoteHarvest(params: QuoteHarvestParams, ctx: QuoteHarvestContext): Promise<QuoteHarvestResult>;

package/dist/quotes/quoteHarvest.js

@@ -0,0 +1,105 @@
+import { ZeroAddress, } from 'ethers';
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import { GURU_TOKEN_MAINNET, MANAGEMENT_FEE_COOLDOWN_DAYS, MANAGEMENT_FEE_ELIGIBLE_GOVERNANCE_TOKEN_RATIO, MAX_BPS, UNIT, } from '../constants.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import FundDataFetcher, { WEIGHT_DENOMINATOR, } from '../helpers/FundDataFetcher.js';
+import { getRouteOut } from '../router/index.js';
+import { quoteHarvestSchema } from '../schemas/quoteHarvest.js';
+import buildHarvestTx from '../txBuilders/buildHarvestTx.js';
+import { FundLedger__factory, HarvestController__factory } from '../typechain/index.js';
+import ReceiptParser from '../helpers/ReceiptParser.js';
+const NORMALIZER = BigInt(1e12);
+const ONE_DAY_IN_MS = 86400n * 1000n;
+const slippageE2For = (settings, token) => {
+    const slippage = settings?.[token.toLowerCase()];
+    return slippage == null ? undefined : Number(slippage / 10n);
+};
+export default async function quoteHarvest(params, ctx) {
+    const parsed = quoteHarvestSchema.parse(params);
+    const addresses = getGuruProtocolAddresses(ctx.chainId);
+    const isStablecoin = compareAddresses(parsed.coin, addresses.tokens.USDC) ||
+        compareAddresses(parsed.coin, addresses.tokens.USDT);
+    if (!isStablecoin) {
+        throw new Error(`[@guru-fund/sdk] quoteHarvest: coin ${parsed.coin} is not a supported stablecoin on chainId ${ctx.chainId}`);
+    }
+    const provider = ctx.provider;
+    const ledger = FundLedger__factory.connect(parsed.ledger, provider);
+    const fetcher = new FundDataFetcher({
+        chainId: ctx.chainId,
+        provider,
+        getPriceUsd1e18: ctx.getPriceUsd1e18,
+    });
+    const [fundData, vault, manager, controllerAddress, profitFeeBps, totalPrincipal, totalVirtualBuffer, latestManagementFeeTimestamp,] = await Promise.all([
+        fetcher.fetchFundData(ledger),
+        ledger.vault(),
+        ledger.manager(),
+        ledger.controller(),
+        ledger.profitFeeBps(),
+        ledger.totalPrincipal(),
+        ledger.totalVirtualBuffer(),
+        ledger.latestManagementFeeTimestamp(),
+    ]);
+    const tvl = fundData.totalValueLocked * NORMALIZER;
+    const guruWeight1e18 = ((fundData.assets.find((asset) => compareAddresses(asset.token.address, GURU_TOKEN_MAINNET))?.weight ?? 0n) *
+        UNIT) /
+        WEIGHT_DENOMINATOR;
+    const isManagementFeeEligible = parsed.isManagementFeeEligible ??
+        guruWeight1e18 >= MANAGEMENT_FEE_ELIGIBLE_GOVERNANCE_TOKEN_RATIO;
+    const latestManagementFeeMs = Number(latestManagementFeeTimestamp) * 1000;
+    const nextManagementFeeTimestampMs = BigInt(latestManagementFeeMs) +
+        ONE_DAY_IN_MS * MANAGEMENT_FEE_COOLDOWN_DAYS;
+    const ledgerBalance = await ledger.balanceOf(ledger.target);
+    const managementFee = BigInt(Date.now()) >= nextManagementFeeTimestampMs
+        ? (fundData.tokenPrice * ledgerBalance) / UNIT
+        : 0n;
+    const feeApplicableAmount = tvl - (totalPrincipal + totalVirtualBuffer);
+    const harvestProjection = managementFee + (profitFeeBps * feeApplicableAmount) / MAX_BPS;
+    const harvestableFraction = tvl > 0n && harvestProjection > 0n
+        ? (harvestProjection * UNIT) / tvl
+        : 0n;
+    const isNoOp = harvestProjection <= 0n && managementFee <= 0n;
+    const extCalls = isNoOp
+        ? []
+        : await Promise.all(fundData.assets.map(async (asset) => {
+            if (compareAddresses(asset.token.address, parsed.coin)) {
+                return { adapter: ZeroAddress, callData: '0x' };
+            }
+            const route = await getRouteOut({
+                chainId: ctx.chainId,
+                tokenIn: asset.token.address,
+                tokenOut: parsed.coin,
+                amountIn: (harvestableFraction * asset.balance) / UNIT,
+                slippageE2: slippageE2For(parsed.slippageSettings, asset.token.address),
+                account: vault,
+                vault,
+            }, ctx);
+            return { adapter: route.adapter, callData: route.callData };
+        }));
+    const txData = buildHarvestTx({
+        controller: controllerAddress,
+        ledger: parsed.ledger,
+        coin: parsed.coin,
+        fraction: isNoOp ? 0n : harvestableFraction,
+        isManagementFeeEligible,
+        extCalls,
+        from: manager,
+    });
+    const decodeLogs = (logs) => {
+        try {
+            const parser = ReceiptParser.fromSimulationLogs(logs);
+            const controller = HarvestController__factory.connect(controllerAddress, provider);
+            const harvested = parser.getDecodedLog(controller.interface, controller.getEvent('Harvested'));
+            return { harvestableAmount: harvested.managerFee / NORMALIZER };
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        extCalls,
+        harvestableFraction: isNoOp ? 0n : harvestableFraction,
+        managementFee: isNoOp ? 0n : managementFee,
+        txData,
+        decodeLogs,
+    };
+}

package/dist/quotes/quoteRebalance.d.ts

@@ -0,0 +1,51 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+import { type GuruProtocolChainId } from '../addresses';
+import { type GetPriceUsd1e18 } from '../helpers/FundDataFetcher';
+import { type RouterContext } from '../router';
+export type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface QuoteRebalanceTargetWeight {
+    token: string;
+    weight: number | bigint;
+}
+export interface QuoteRebalanceParams {
+    ledger: string;
+    targetWeights: QuoteRebalanceTargetWeight[];
+    slippageSettings?: Record<string, string | number | bigint>;
+}
+export interface QuoteRebalanceContext extends RouterContext {
+    chainId: GuruProtocolChainId;
+    getPriceUsd1e18: GetPriceUsd1e18;
+}
+export interface QuoteRebalanceTrade {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    expectedAmountOut: bigint;
+}
+export interface QuoteRebalanceLogTrade {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    amountOut: bigint;
+}
+export interface QuoteRebalanceLogs {
+    trades: QuoteRebalanceLogTrade[];
+}
+export type SimulationLog = {
+    address: string;
+    data: string;
+    topics: string[];
+};
+export type QuoteRebalanceEmptyReason = 'balanced' | 'dust' | null;
+export interface QuoteRebalanceResult {
+    extCalls: ExternalCallStruct[];
+    trades: QuoteRebalanceTrade[];
+    cumulativeSlippageBps: bigint;
+    txData: TransactionRequest;
+    decodeLogs: (logs: SimulationLog[]) => QuoteRebalanceLogs | null;
+    emptyReason: QuoteRebalanceEmptyReason;
+}
+export default function quoteRebalance(params: QuoteRebalanceParams, ctx: QuoteRebalanceContext): Promise<QuoteRebalanceResult>;