@guru-fund/sdk 0.2.4 → 0.2.6

package/dist/helpers/ReceiptParser.d.ts

@@ -1,6 +1,6 @@
 import { ContractTransactionReceipt, Interface } from 'ethers';
 import { TypedContractEvent } from '../typechain/common';
-type TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+type TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? keyof V extends never ? any : V : any;
 export default class ReceiptParser {
     private receipt;
     constructor(receipt: ContractTransactionReceipt);

package/dist/quotes/quoteDeposit.d.ts

@@ -37,5 +37,12 @@ export interface QuoteDepositResult {
     txData: TransactionRequest;
     decodeLogs: (logs: SimulationLog[]) => QuoteDepositLogs | null;
 }
+type DepositAllocationQuote = {
+    asset: Fund.Asset;
+    amountIn: bigint;
+    amountOut: bigint;
+};
 export declare function allocateDepositInputAmounts(assets: Fund.Asset[], totalAmount: bigint, totalValueLocked: bigint): Map<string, bigint>;
+export declare function rebalanceDepositInputAmounts(quotes: DepositAllocationQuote[], totalAmount: bigint): Map<string, bigint>;
 export default function quoteDeposit(params: QuoteDepositParams, ctx: QuoteDepositContext): Promise<QuoteDepositResult>;
+export {};

package/dist/quotes/quoteDeposit.js

@@ -8,28 +8,30 @@ 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 MIN_ROUTE_INPUT_AMOUNT = 2n;
+const ROUTE_AWARE_ALLOCATION_PASSES = 1;
 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) {
+function allocateWeightedInputAmounts(items, totalAmount) {
     const allocations = new Map();
-    if (totalAmount === 0n || totalValueLocked === 0n) {
-        for (const asset of assets) {
-            allocations.set(asset.token.address.toLowerCase(), 0n);
-        }
+    if (totalAmount === 0n) {
+        for (const item of items)
+            allocations.set(item.key, 0n);
         return allocations;
     }
-    const weighted = assets.map((asset) => {
-        const usdValue = assetUsd1e18Value(asset);
-        const weightedAmount = totalAmount * usdValue;
-        const amount = weightedAmount / totalValueLocked;
+    const weighted = items.map((item) => {
+        const weightedAmount = totalAmount * item.weight;
+        const amount = item.denominator === 0n ? 0n : weightedAmount / item.denominator;
         return {
-            asset,
+            ...item,
             amount,
-            remainder: weightedAmount % totalValueLocked,
+            remainder: item.denominator === 0n
+                ? 0n
+                : weightedAmount % item.denominator,
         };
     });
     const allocated = weighted.reduce((sum, item) => sum + item.amount, 0n);
@@ -38,11 +40,116 @@ export function allocateDepositInputAmounts(assets, totalAmount, totalValueLocke
         .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);
+        allocations.set(item.key, item.amount + extra);
         remainder -= extra;
     });
+    const zeroRoundedAssets = weighted
+        .filter((item) => item.balance > 0n && (allocations.get(item.key) ?? 0n) === 0n)
+        .sort((a, b) => a.remainder === b.remainder ? 0 : a.remainder > b.remainder ? -1 : 1);
+    for (const item of zeroRoundedAssets) {
+        const donor = weighted
+            .filter((candidate) => candidate.key !== item.key)
+            .sort((a, b) => {
+            const aAmount = allocations.get(a.key) ?? 0n;
+            const bAmount = allocations.get(b.key) ?? 0n;
+            return aAmount === bAmount ? 0 : aAmount > bAmount ? -1 : 1;
+        })
+            .find((candidate) => (allocations.get(candidate.key) ?? 0n) >
+            MIN_ROUTE_INPUT_AMOUNT);
+        if (!donor)
+            break;
+        allocations.set(donor.key, (allocations.get(donor.key) ?? 0n) - MIN_ROUTE_INPUT_AMOUNT);
+        allocations.set(item.key, MIN_ROUTE_INPUT_AMOUNT);
+    }
     return allocations;
 }
+export function allocateDepositInputAmounts(assets, totalAmount, totalValueLocked) {
+    if (totalAmount === 0n || totalValueLocked === 0n) {
+        const allocations = new Map();
+        for (const asset of assets) {
+            allocations.set(asset.token.address.toLowerCase(), 0n);
+        }
+        return allocations;
+    }
+    return allocateWeightedInputAmounts(assets.map((asset) => ({
+        key: asset.token.address.toLowerCase(),
+        weight: assetUsd1e18Value(asset),
+        denominator: totalValueLocked,
+        balance: asset.balance,
+    })), totalAmount);
+}
+export function rebalanceDepositInputAmounts(quotes, totalAmount) {
+    let denominator = 0n;
+    const weights = quotes.map(({ asset, amountIn, amountOut }) => {
+        let weight = 0n;
+        if (asset.balance > 0n && amountIn > 0n && amountOut > 0n) {
+            const inputRatio = (amountOut * UNIT) / asset.balance;
+            if (inputRatio > 0n) {
+                weight = (amountIn * UNIT) / inputRatio;
+            }
+        }
+        denominator += weight;
+        return {
+            key: asset.token.address.toLowerCase(),
+            weight,
+            denominator: 0n,
+            balance: asset.balance,
+        };
+    });
+    if (denominator === 0n) {
+        return new Map(quotes.map(({ asset, amountIn }) => [
+            asset.token.address.toLowerCase(),
+            amountIn,
+        ]));
+    }
+    return allocateWeightedInputAmounts(weights.map((item) => ({ ...item, denominator })), totalAmount);
+}
+function allocationsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [key, value] of a) {
+        if (b.get(key) !== value)
+            return false;
+    }
+    return true;
+}
+async function quoteDepositAllocations({ inputAllocations, coinData, fundData, parsed, ctx, vault, }) {
+    const allocationQuotes = [];
+    if (coinData) {
+        const amountIn = inputAllocations.get(coinData.token.address.toLowerCase()) ?? 0n;
+        if (coinData.balance > 0n && amountIn === 0n) {
+            throw new Error(`Deposit amount is too small to allocate input for asset ${coinData.token.address}`);
+        }
+        allocationQuotes.push({
+            asset: coinData,
+            amountIn,
+            amountOut: amountIn,
+        });
+    }
+    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,
+            slippageE2: slippageE2For(parsed.slippageSettings, asset.token.address),
+        }, ctx);
+        allocationQuotes.push({
+            asset,
+            amountIn,
+            amountOut: BigInt(route.data.amountToReceive),
+        });
+        return { asset, amountIn, route };
+    }));
+    return { allocationQuotes, routeResults };
+}
 export default async function quoteDeposit(params, ctx) {
     const parsed = quoteDepositSchema.parse(params);
     if (parsed.referrerFeeBps < 0n || parsed.referrerFeeBps > MAX_BPS) {
@@ -65,32 +172,36 @@ export default async function quoteDeposit(params, ctx) {
     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,
+    let inputAllocations = allocateDepositInputAmounts(fundData.assets, adjustedAmount, fundData.totalValueLocked);
+    let quoted = await quoteDepositAllocations({
+        inputAllocations,
+        coinData,
+        fundData,
+        parsed,
+        ctx,
+        vault,
+    });
+    for (let i = 0; i < ROUTE_AWARE_ALLOCATION_PASSES; i++) {
+        const rebalanced = rebalanceDepositInputAmounts(quoted.allocationQuotes, adjustedAmount);
+        if (allocationsEqual(inputAllocations, rebalanced))
+            break;
+        inputAllocations = rebalanced;
+        quoted = await quoteDepositAllocations({
+            inputAllocations,
+            coinData,
+            fundData,
+            parsed,
+            ctx,
             vault,
-        }, ctx);
-        return { asset, route };
-    }));
+        });
+    }
+    let lowestInputRatio = MAX_UINT256;
+    for (const { asset, amountOut } of quoted.allocationQuotes) {
+        if (asset.balance === 0n)
+            continue;
+        lowestInputRatio = minBigint(lowestInputRatio, (amountOut * UNIT) / asset.balance);
+    }
+    const routeResults = quoted.routeResults;
     const coinToken = await new Token(parsed.coin, provider).metadata();
     const coinUsd1e18Price = await ctx.getPriceUsd1e18(parsed.coin);
     const externalTokenMetadata = new Map();
@@ -142,7 +253,6 @@ export default async function quoteDeposit(params, ctx) {
             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);

package/dist/router/getUniswapV4Route.d.ts

@@ -15,6 +15,7 @@ export declare function connectV4Quoter(address: string, provider: Provider): V4
 export declare function toAdapterPathKeys(path: V4Path): SwapV4Struct['path'];
 type V4QuoteSource = 'quoter' | 'adapter-preview';
 export interface ApplyV4TollParams {
+    tollIn: boolean;
     baseToll: {
         currency: string;
         amount: bigint;
@@ -32,7 +33,7 @@ export interface ApplyV4TollResult {
     amountToSend: bigint;
     initialTollAmount: bigint;
 }
-export declare function applyV4Toll({ baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }: ApplyV4TollParams): ApplyV4TollResult;
+export declare function applyV4Toll({ tollIn, baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }: ApplyV4TollParams): ApplyV4TollResult;
 export declare function toHookAdapterPathKeys(path: V4Path): V4HookPathKey[];
 export interface GetUniswapV4RouteContext {
     provider: Provider;

package/dist/router/getUniswapV4Route.js

@@ -45,15 +45,17 @@ function isV4HookLockedError(reason) {
     }
     return false;
 }
-export function applyV4Toll({ baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }) {
+export function applyV4Toll({ tollIn, baseToll, quotedAmountToReceive, quoteSource, swapAmountIn, }) {
     const toll = { ...baseToll };
     let amountQuoted = quotedAmountToReceive;
     let amountToSend = swapAmountIn;
     let initialTollAmount = toll.amount;
     if (toll.amount === 0n) {
         if (quoteSource === 'quoter') {
-            toll.amount = quotedAmountToReceive / TOLL_DIVISOR_20BPS;
-            amountQuoted -= toll.amount;
+            if (!tollIn) {
+                toll.amount = quotedAmountToReceive / TOLL_DIVISOR_20BPS;
+                amountQuoted -= toll.amount;
+            }
         }
         initialTollAmount = 0n;
     }
@@ -194,7 +196,7 @@ export default async function getUniswapV4Route(params, ctx) {
         throw new Error(`UniswapV4 not supported on chainId ${chainId}`);
     }
     const maxSlippageE3 = slippageE2 != null ? BigInt(slippageE2) * 10n : undefined;
-    const { baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
+    const { tollIn, baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
     const candidates = await discoverV4Paths(chainId, tokenIn, tokenOut, provider);
     if (candidates.length === 0) {
         throw new Error('NO_UNISWAP_V4_ROUTES_FOUND');
@@ -254,6 +256,7 @@ export default async function getUniswapV4Route(params, ctx) {
     const selectedAdapter = bestQuote.adapter ?? adapter;
     const bestPath = bestQuote.path;
     const { toll, amountQuoted, amountToSend, initialTollAmount } = applyV4Toll({
+        tollIn,
         baseToll,
         quotedAmountToReceive: bestQuote.amountToReceive,
         quoteSource: bestQuote.source,
@@ -296,6 +299,7 @@ export default async function getUniswapV4Route(params, ctx) {
         amountToSend,
         amountQuoted,
         initialTollAmount,
+        outputTollE3: tollIn ? 0n : undefined,
         maxSlippageE3,
     });
     return {

package/dist/router/getVeloraRoute.js

@@ -20,7 +20,7 @@ export default async function getVeloraRoute(params, ctx) {
         tokenOutDecimals ?? fetchDecimals(tokenOut, provider),
         FundVault__factory.connect(vault, provider).controller(),
     ]);
-    const { baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
+    const { tollIn, baseToll, swapAmountIn } = resolveBaseToll(addresses, tokenIn, tokenOut, amountIn);
     const routes = (await Promise.all(SUPPORTED_DEXS.map(async (dex) => {
         try {
             if (!isDexConfigured(addresses, dex))
@@ -47,6 +47,7 @@ export default async function getVeloraRoute(params, ctx) {
                 dex,
                 cachedPath,
                 amountIn: swapAmountIn,
+                tollIn,
                 toll,
                 vault,
                 controller,

package/dist/router/poolHelper.js

@@ -496,6 +496,7 @@ export default class PoolHelper {
                     amountToSend: inputAmount,
                     amountQuoted: lastAmount(amounts, exchangeFactory),
                     initialTollAmount: swapFee,
+                    outputTollE3: 0n,
                     slippage,
                     buildSwap: (amountToReceive) => {
                         const data = {
@@ -527,6 +528,7 @@ export default class PoolHelper {
                 amountToSend: inputAmount,
                 amountQuoted: lastAmount(amounts, exchangeFactory),
                 initialTollAmount: swapFee,
+                outputTollE3: 0n,
                 slippage,
                 buildSwap: (amountToReceive) => {
                     const data = {
@@ -590,6 +592,7 @@ export default class PoolHelper {
             amountToSend: inputAmount,
             amountQuoted: amountOut,
             initialTollAmount: swapFee,
+            outputTollE3: 0n,
             slippage,
             buildSwap: (amountToReceive) => {
                 const data = {

package/dist/router/velora.d.ts

@@ -30,6 +30,7 @@ export interface GetRouteFromPathParams {
     dex: SupportedDex;
     cachedPath: CachedPath;
     amountIn: bigint;
+    tollIn: boolean;
     toll: {
         currency: string;
         amount: bigint;
@@ -40,5 +41,5 @@ export interface GetRouteFromPathParams {
     maxSlippageE3?: bigint;
     prefixTxs?: PrefixTx[];
 }
-export declare function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }: GetRouteFromPathParams): Promise<Route>;
+export declare function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, tollIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }: GetRouteFromPathParams): Promise<Route>;
 export {};

package/dist/router/velora.js

@@ -83,7 +83,7 @@ function encodeV3Path(path) {
     }
     return solidityPacked(pathEncoding, pathToEncode);
 }
-export async function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }) {
+export async function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, tollIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }) {
     if (!cachedPath) {
         throw new Error('No cached path');
     }
@@ -107,7 +107,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             ]);
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -140,6 +140,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {
@@ -175,7 +176,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             ]);
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -208,6 +209,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {
@@ -271,7 +273,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             }
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -307,6 +309,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {
@@ -345,7 +348,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
             ]);
             let amountQuoted = grossAmountToReceive;
             let amountToSend = amountIn;
-            if (toll.amount === 0n) {
+            if (!tollIn && toll.amount === 0n) {
                 toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
                 amountQuoted -= toll.amount;
             }
@@ -379,6 +382,7 @@ export async function getRouteFromPath({ chainId, addresses, provider, simulator
                 amountToSend,
                 amountQuoted,
                 initialTollAmount: toll.amount,
+                outputTollE3: tollIn ? 0n : undefined,
                 maxSlippageE3,
             });
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@guru-fund/sdk",
-    "version": "0.2.4",
+    "version": "0.2.6",
     "description": "Guru Protocol SDK — quote + transaction builders for on-chain managed funds.",
     "license": "MIT",
     "type": "module",
@@ -53,7 +53,7 @@
         "clean": "rm -rf dist .turbo tsconfig.build.tsbuildinfo",
         "typecheck": "tsc --noEmit",
         "test": "node --import tsx --test test/*.test.ts",
-        "prepack": "pnpm run build"
+        "prepack": "npm run build"
     },
     "dependencies": {
         "ethers": "=6.15.0",