@guru-fund/sdk 0.2.6 → 0.2.8

package/README.md

@@ -23,7 +23,7 @@ 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
+    chainId: 1, // mainnet (1), base (8453), and Robinhood (4663) are supported
 })
 ```
 
@@ -32,7 +32,7 @@ const protocol = new GuruProtocol({
 -   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 }`.
+-   Throws `UnsupportedChainError` for any chain outside `{ 1, 8453, 4663 }`.
 
 Optional override slots (`GuruProtocolOptions`): `simulator`, `getSwapFeePercentage`,
 `getPriceUsd1e18`, `veloraEndpoint`, `getPath`. Each has a sensible default —
@@ -213,7 +213,7 @@ const decoded = quote.decodeLogs(receipt!.logs) ?? {
 ## Errors
 
 -   `UnsupportedChainError` — thrown by the constructor on `chainId` outside
-    `{ 1, 8453 }`.
+    `{ 1, 8453, 4663 }`.
 -   `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

package/dist/GuruProtocol.d.ts

@@ -3,11 +3,13 @@ import { type GuruProtocolAddresses, type GuruProtocolChainId } from './addresse
 import type { GetPriceUsd1e18 } from './helpers/FundDataFetcher';
 import { type QuoteDepositParams, type QuoteDepositResult } from './quotes/quoteDeposit';
 import { type QuoteHarvestParams, type QuoteHarvestResult } from './quotes/quoteHarvest';
+import { type QuoteCloseParams, type QuoteCloseResult } from './quotes/quoteClose';
 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 buildCloseTx from './txBuilders/buildCloseTx';
 import buildDepositTx from './txBuilders/buildDepositTx';
 import buildHarvestTx from './txBuilders/buildHarvestTx';
 import buildTradeTx from './txBuilders/buildTradeTx';
@@ -35,8 +37,10 @@ export declare class GuruProtocol {
     quoteWithdrawal(params: QuoteWithdrawalParams): Promise<QuoteWithdrawalResult>;
     quoteTrade(params: QuoteTradeParams): Promise<QuoteTradeResult>;
     quoteHarvest(params: QuoteHarvestParams): Promise<QuoteHarvestResult>;
+    quoteClose(params: QuoteCloseParams): Promise<QuoteCloseResult>;
     quoteRebalance(params: QuoteRebalanceParams): Promise<QuoteRebalanceResult>;
     static buildDepositTx: typeof buildDepositTx;
+    static buildCloseTx: typeof buildCloseTx;
     static buildWithdrawTx: typeof buildWithdrawTx;
     static buildHarvestTx: typeof buildHarvestTx;
     static buildTradeTx: typeof buildTradeTx;

package/dist/GuruProtocol.js

@@ -2,11 +2,13 @@ import { JsonRpcProvider } from 'ethers';
 import { getGuruProtocolAddresses, isSupportedChainId, UnsupportedChainError, } from './addresses.js';
 import quoteDeposit from './quotes/quoteDeposit.js';
 import quoteHarvest from './quotes/quoteHarvest.js';
+import quoteClose from './quotes/quoteClose.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 buildCloseTx from './txBuilders/buildCloseTx.js';
 import buildDepositTx from './txBuilders/buildDepositTx.js';
 import buildHarvestTx from './txBuilders/buildHarvestTx.js';
 import buildTradeTx from './txBuilders/buildTradeTx.js';
@@ -64,10 +66,14 @@ export class GuruProtocol {
     quoteHarvest(params) {
         return quoteHarvest(params, this.routerCtx());
     }
+    quoteClose(params) {
+        return quoteClose(params, this.routerCtx());
+    }
     quoteRebalance(params) {
         return quoteRebalance(params, this.routerCtx());
     }
     static buildDepositTx = buildDepositTx;
+    static buildCloseTx = buildCloseTx;
     static buildWithdrawTx = buildWithdrawTx;
     static buildHarvestTx = buildHarvestTx;
     static buildTradeTx = buildTradeTx;

package/dist/addresses.d.ts

@@ -1,4 +1,4 @@
-export type GuruProtocolChainId = 1 | 8453;
+export type GuruProtocolChainId = 1 | 8453 | 4663;
 type AdapterKey = 'uniswapV2' | 'uniswapV3' | 'uniswapV4' | 'uniswapV4Hook' | 'pancakeV2' | 'pancakeV3' | 'aerodromeV2' | 'aerodromeV3';
 type FactoryKey = AdapterKey | 'aerodromeV3Bis';
 type RouterKey = AdapterKey;
@@ -26,6 +26,7 @@ export type GuruProtocolAddresses = {
         WETH: string;
         USDC: string;
         USDT: string;
+        USDG?: string;
     }>;
     readonly migrator?: string;
 };

package/dist/addresses.js

@@ -95,14 +95,48 @@ const BASE = {
     },
     migrator: '0x209656784c8eb405765288c8f447d11c0aa1a3d3',
 };
+const ROBINHOOD = {
+    chainId: 4663,
+    protocol: '0xe0d99cd8bf9f091713c88ff763d669ad3703876c',
+    vaultImplementation: '0x70451b00c42a73ea2d9707ddc7413aff8620be85',
+    ledgerImplementation: '0xa8644a5eb1cf74f0d8c7771d3bca9cb5f4edd6a5',
+    controllers: {
+        fund: '0x36e2de2f1b66ecaa5fda2196abb88ce663616533',
+    },
+    adapters: {
+        uniswapV2: '0xdeb704836165043c172ae80467249ff87429605f',
+        uniswapV3: '0x34e1efca367b1686af9bc3eb9a593c02c2b295f6',
+        uniswapV4: '0x907e28e12a36a41a9cf01e1f455f4778408da198',
+    },
+    factories: {
+        uniswapV2: '0x8bceaa40b9acdfaedf85adf4ff01f5ad6517937f',
+        uniswapV3: '0x1f7d7550b1b028f7571e69a784071f0205fd2efa',
+    },
+    routers: {
+        uniswapV2: '0x89e5db8b5aa49aa85ac63f691524311aeb649eba',
+        uniswapV3: '0xcaf681a66d020601342297493863e78c959e5cb2',
+        uniswapV4: '0x8876789976decbfcbbbe364623c63652db8c0904',
+    },
+    quoters: {
+        uniswapV3: '0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7',
+        uniswapV4: '0x8dc178efb8111bb0973dd9d722ebeff267c98f94',
+    },
+    tokens: {
+        WETH: '0x0bd7d308f8e1639fab988df18a8011f41eacad73',
+        USDC: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',
+        USDT: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',
+        USDG: '0x5fc5360d0400a0fd4f2af552add042d716f1d168',
+    },
+};
 export const GURU_PROTOCOL_ADDRESSES = {
     1: MAINNET,
     8453: BASE,
+    4663: ROBINHOOD,
 };
 export const SUPPORTED_CHAIN_IDS = [
-    1, 8453,
+    1, 8453, 4663,
 ];
-export const isSupportedChainId = (chainId) => chainId === 1 || chainId === 8453;
+export const isSupportedChainId = (chainId) => chainId === 1 || chainId === 8453 || chainId === 4663;
 export function getGuruProtocolAddresses(chainId) {
     if (!isSupportedChainId(chainId)) {
         throw new UnsupportedChainError(chainId);

package/dist/index.d.ts

@@ -3,11 +3,12 @@ export { GURU_PROTOCOL_ADDRESSES, SUPPORTED_CHAIN_IDS, UnsupportedChainError, ge
 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 { BuildDepositTxParams, BuildCloseTxParams, 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 { QuoteCloseParams, QuoteCloseResult } from './quotes/quoteClose';
 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';

package/dist/quotes/quoteClose.d.ts

@@ -0,0 +1,22 @@
+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 QuoteCloseParams {
+    ledger: string;
+    coin: string;
+    slippageSettings?: Record<string, bigint>;
+}
+export interface QuoteCloseContext extends RouterContext {
+    chainId: GuruProtocolChainId;
+    getPriceUsd1e18: GetPriceUsd1e18;
+}
+export interface QuoteCloseResult {
+    extCalls: ExternalCallStruct[];
+    txData: TransactionRequest;
+}
+export default function quoteClose(params: QuoteCloseParams, ctx: QuoteCloseContext): Promise<QuoteCloseResult>;

package/dist/quotes/quoteClose.js

@@ -0,0 +1,57 @@
+import { ZeroAddress, } from 'ethers';
+import { getGuruProtocolAddresses, } from '../addresses.js';
+import compareAddresses from '../helpers/compareAddresses.js';
+import FundDataFetcher from '../helpers/FundDataFetcher.js';
+import { getRouteOut } from '../router/index.js';
+import { stablecoinAddresses } from '../router/helpers.js';
+import { quoteCloseSchema } from '../schemas/quoteClose.js';
+import buildCloseTx from '../txBuilders/buildCloseTx.js';
+import { FundLedger__factory } from '../typechain/index.js';
+const slippageE2For = (settings, token) => {
+    const slippage = settings?.[token.toLowerCase()];
+    return slippage == null ? undefined : Number(slippage / 10n);
+};
+export default async function quoteClose(params, ctx) {
+    const parsed = quoteCloseSchema.parse(params);
+    const addresses = getGuruProtocolAddresses(ctx.chainId);
+    const isStablecoin = stablecoinAddresses(addresses).some((stable) => compareAddresses(parsed.coin, stable));
+    if (!isStablecoin) {
+        throw new Error(`[@guru-fund/sdk] quoteClose: 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] = await Promise.all([
+        fetcher.fetchFundData(ledger),
+        ledger.vault(),
+        ledger.manager(),
+        ledger.controller(),
+    ]);
+    const extCalls = 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: asset.balance,
+            slippageE2: slippageE2For(parsed.slippageSettings, asset.token.address),
+            account: vault,
+            vault,
+        }, ctx);
+        return { adapter: route.adapter, callData: route.callData };
+    }));
+    const txData = buildCloseTx({
+        controller: controllerAddress,
+        ledger: parsed.ledger,
+        coin: parsed.coin,
+        extCalls,
+        from: manager,
+    });
+    return { extCalls, txData };
+}

package/dist/quotes/quoteHarvest.js

@@ -4,6 +4,7 @@ import { GURU_TOKEN_MAINNET, MANAGEMENT_FEE_COOLDOWN_DAYS, MANAGEMENT_FEE_ELIGIB
 import compareAddresses from '../helpers/compareAddresses.js';
 import FundDataFetcher, { WEIGHT_DENOMINATOR, } from '../helpers/FundDataFetcher.js';
 import { getRouteOut } from '../router/index.js';
+import { stablecoinAddresses } from '../router/helpers.js';
 import { quoteHarvestSchema } from '../schemas/quoteHarvest.js';
 import buildHarvestTx from '../txBuilders/buildHarvestTx.js';
 import { FundLedger__factory, HarvestController__factory } from '../typechain/index.js';
@@ -17,8 +18,7 @@ const slippageE2For = (settings, token) => {
 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);
+    const isStablecoin = stablecoinAddresses(addresses).some((stable) => compareAddresses(parsed.coin, stable));
     if (!isStablecoin) {
         throw new Error(`[@guru-fund/sdk] quoteHarvest: coin ${parsed.coin} is not a supported stablecoin on chainId ${ctx.chainId}`);
     }

package/dist/router/constants.d.ts

@@ -16,3 +16,4 @@ export declare const V4_ZERO_ADDRESS = "0x00000000000000000000000000000000000000
 export declare const DEXSCREENER_ENDPOINT = "https://api.dexscreener.com/token-pairs/v1";
 export declare const V4_DISCOVERY_MIN_LIQUIDITY_USD = 10000;
 export declare const V4_DISCOVERY_MAX_POOLS = 3;
+export declare const V4_DISCOVERY_MAX_LP_FEE = 100000;

package/dist/router/constants.js

@@ -25,3 +25,4 @@ export const V4_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 export const DEXSCREENER_ENDPOINT = 'https://api.dexscreener.com/token-pairs/v1';
 export const V4_DISCOVERY_MIN_LIQUIDITY_USD = 10_000;
 export const V4_DISCOVERY_MAX_POOLS = 3;
+export const V4_DISCOVERY_MAX_LP_FEE = 100_000;

package/dist/router/helpers.d.ts

@@ -8,4 +8,5 @@ export interface BaseTollContext {
     };
     swapAmountIn: bigint;
 }
+export declare function stablecoinAddresses(addresses: GuruProtocolAddresses): string[];
 export declare function resolveBaseToll(addresses: GuruProtocolAddresses, tokenIn: string, tokenOut: string, amountIn: bigint): BaseTollContext;

package/dist/router/helpers.js

@@ -5,12 +5,17 @@ export function withSlippageTolerance(amount, slippage) {
     const tolerance = (amount * slippage) / PERCENTAGE_DENOMINATOR;
     return amount - tolerance;
 }
+export function stablecoinAddresses(addresses) {
+    return [
+        addresses.tokens.USDC,
+        addresses.tokens.USDT,
+        addresses.tokens.USDG,
+    ].filter((token) => Boolean(token));
+}
 export function resolveBaseToll(addresses, tokenIn, tokenOut, amountIn) {
-    const tollableTokens = [
-        addresses.tokens.USDC.toLowerCase(),
-        addresses.tokens.USDT.toLowerCase(),
-        addresses.tokens.WETH.toLowerCase(),
-    ];
+    const tollableTokens = stablecoinAddresses(addresses)
+        .concat(addresses.tokens.WETH)
+        .map((token) => token.toLowerCase());
     const tollIn = tollableTokens.some((token) => compareAddresses(token, tokenIn));
     const tollOut = !tollIn &&
         tollableTokens.some((token) => compareAddresses(token, tokenOut));

package/dist/router/index.d.ts

@@ -10,6 +10,7 @@ export interface RouterContext {
     getPath: PathFetcher;
 }
 export declare function veloraThenV4Discovery(velora: () => Promise<Route>, v4Discovery: () => Promise<Route>): Promise<Route>;
+export declare function bestOfV4AndFallback(v4Discovery: () => Promise<Route>, fallback: () => Promise<Route>): Promise<Route>;
 export declare function tryWithVeloraFallback<T>(velora: () => Promise<T>, fallback: () => Promise<T>): Promise<T>;
 export declare function getRouteIn(params: RouteSearchParams, ctx: RouterContext): Promise<Route>;
 export declare function getRouteOut(params: RouteSearchParams, ctx: RouterContext): Promise<Route>;

package/dist/router/index.js

@@ -5,6 +5,7 @@ import { Token } from '../helpers/Token.js';
 import { getFallbackRouteIn, getFallbackRouteOut, } from './getFallbackRoutes.js';
 import getUniswapV4Route, { connectV4Quoter, toAdapterPathKeys, } from './getUniswapV4Route.js';
 import getVeloraRoute from './getVeloraRoute.js';
+import { stablecoinAddresses } from './helpers.js';
 import PoolHelper from './poolHelper.js';
 import { discoverV4Paths } from './v4PoolDiscovery.js';
 const AERO_V3_FACTORY_ABI = [
@@ -42,6 +43,29 @@ export async function veloraThenV4Discovery(velora, v4Discovery) {
         return await v4Discovery();
     }
 }
+export async function bestOfV4AndFallback(v4Discovery, fallback) {
+    const [v4Result, fallbackResult] = await Promise.allSettled([
+        v4Discovery(),
+        fallback(),
+    ]);
+    if (v4Result.status === 'rejected' &&
+        v4Result.reason instanceof Error &&
+        (v4Result.reason.message.includes('TOKEN_LOCKED_BY_V4_HOOK') ||
+            v4Result.reason.message.includes('UNISWAP_V4_HOOK_ROUTE_REVERTED'))) {
+        throw v4Result.reason;
+    }
+    if (v4Result.status === 'fulfilled' && fallbackResult.status === 'fulfilled') {
+        return BigInt(v4Result.value.data.amountToReceive) >=
+            BigInt(fallbackResult.value.data.amountToReceive)
+            ? v4Result.value
+            : fallbackResult.value;
+    }
+    if (v4Result.status === 'fulfilled')
+        return v4Result.value;
+    if (fallbackResult.status === 'fulfilled')
+        return fallbackResult.value;
+    throw fallbackResult.reason;
+}
 export async function tryWithVeloraFallback(velora, fallback) {
     try {
         return await velora();
@@ -71,7 +95,12 @@ export async function getRouteIn(params, ctx) {
         simulator: ctx.simulator,
         getSwapFeePercentage: ctx.getSwapFeePercentage,
     };
-    return tryWithVeloraFallback(() => veloraThenV4Discovery(() => getVeloraRoute(params, veloraCtx), () => getUniswapV4Route(params, v4Ctx)), () => getFallbackRouteIn(params, fallbackCtx));
+    try {
+        return await getVeloraRoute(params, veloraCtx);
+    }
+    catch {
+        return bestOfV4AndFallback(() => getUniswapV4Route(params, v4Ctx), () => getFallbackRouteIn(params, fallbackCtx));
+    }
 }
 export async function getRouteOut(params, ctx) {
     const veloraCtx = {
@@ -88,12 +117,16 @@ export async function getRouteOut(params, ctx) {
         simulator: ctx.simulator,
         getSwapFeePercentage: ctx.getSwapFeePercentage,
     };
-    return tryWithVeloraFallback(() => veloraThenV4Discovery(() => getVeloraRoute(params, veloraCtx), () => getUniswapV4Route(params, v4Ctx)), () => getFallbackRouteOut(params, fallbackCtx));
+    try {
+        return await getVeloraRoute(params, veloraCtx);
+    }
+    catch {
+        return bestOfV4AndFallback(() => getUniswapV4Route(params, v4Ctx), () => getFallbackRouteOut(params, fallbackCtx));
+    }
 }
 export async function getPriceUsd1e18(token, ctx) {
     const addresses = getGuruProtocolAddresses(ctx.chainId);
-    if (compareAddresses(token, addresses.tokens.USDC) ||
-        compareAddresses(token, addresses.tokens.USDT)) {
+    if (stablecoinAddresses(addresses).some((stable) => compareAddresses(token, stable))) {
         return 10n ** 18n;
     }
     const poolHelper = new PoolHelper({
@@ -101,7 +134,7 @@ export async function getPriceUsd1e18(token, ctx) {
         provider: ctx.provider,
         getSwapFeePercentage: ctx.getSwapFeePercentage,
     });
-    const stable = addresses.tokens.USDC;
+    const stable = addresses.tokens.USDG ?? addresses.tokens.USDC;
     const { decimals: stableDecimals } = await new Token(stable, ctx.provider)
         .metadata()
         .catch(() => ({ decimals: 6 }));
@@ -309,7 +342,7 @@ async function _priceViaV4Pools(token, oneToken, getWethUsd, ctx) {
         }
         return best > 0n ? best : null;
     };
-    const inUsdc = await quoteVia(addresses.tokens.USDC);
+    const inUsdc = await quoteVia(addresses.tokens.USDG ?? addresses.tokens.USDC);
     if (inUsdc !== null) {
         return inUsdc * 10n ** 12n;
     }

package/dist/router/simulation.js

@@ -45,13 +45,7 @@ export async function findMaxPassingAmountToReceive({ chainId, blockNumber, cont
         .map((result, index) => (result.success ? index : -1))
         .filter((index) => index !== -1);
     if (successIndices.length === 0) {
-        if (maxSlippageE3) {
-            const fallback = withSlippageTolerance(amountQuoted, maxSlippageE3);
-            console.warn(`[findMax] All ${BUNDLE_SIMULATION_CANDIDATES} simulation candidates failed. ` +
-                `Falling back to caller-provided max slippage (${Number(maxSlippageE3) / 1000}%).`, { amountQuoted, fallback, maxSlippageE3 });
-            return fallback;
-        }
-        console.warn('Found no successful simulations with correct slippage, returning initial slippage', {
+        console.warn('Found no successful simulations for executable route quote', {
             chainId,
             blockNumber,
             controller,
@@ -62,7 +56,7 @@ export async function findMaxPassingAmountToReceive({ chainId, blockNumber, cont
             callData: encodeVaultExecute(adapter, buildCallDataForAmount(high)),
             path,
         });
-        return amountWithSlippage;
+        throw new Error('NO_EXECUTABLE_ROUTE_FOUND');
     }
     const [bestIndex, secondBestIndex] = successIndices;
     const targetIndex = secondBestIndex ?? bestIndex;

package/dist/router/v4PoolDiscovery.d.ts

@@ -8,6 +8,7 @@ export interface V4PoolKey {
     tickSpacing: number;
     hooks: string;
 }
+export declare function isSafeDiscoveredV4PoolKey(key: V4PoolKey): boolean;
 export declare function computeV4PoolId(key: V4PoolKey): string;
 interface DexscreenerPair {
     dexId?: string;

package/dist/router/v4PoolDiscovery.js

@@ -1,7 +1,7 @@
-import { AbiCoder, keccak256 } from 'ethers';
+import { AbiCoder, keccak256, zeroPadValue, } from 'ethers';
 import { getGuruProtocolAddresses, } from '../addresses.js';
 import compareAddresses from '../helpers/compareAddresses.js';
-import { DEXSCREENER_ENDPOINT, V4_ZERO_ADDRESS, V4_DISCOVERY_MAX_POOLS, V4_DISCOVERY_MIN_LIQUIDITY_USD, VELORA_NEGATIVE_CACHE_TTL, VELORA_PATH_CACHE_TTL, } from './constants.js';
+import { DEXSCREENER_ENDPOINT, V4_ZERO_ADDRESS, V4_DISCOVERY_MAX_POOLS, V4_DISCOVERY_MAX_LP_FEE, V4_DISCOVERY_MIN_LIQUIDITY_USD, VELORA_NEGATIVE_CACHE_TTL, VELORA_PATH_CACHE_TTL, } from './constants.js';
 const V4_CHAIN_CONFIG = {
     1: {
         dexscreenerSlug: 'ethereum',
@@ -13,8 +13,16 @@ const V4_CHAIN_CONFIG = {
         poolManager: '0x498581ff718922c3f8e6a244956af099b2652b2b',
         deployBlock: 25_000_000,
     },
+    4663: {
+        dexscreenerSlug: 'robinhood',
+        poolManager: '0x8366a39cc670b4001a1121b8f6a443a643e40951',
+        deployBlock: 0,
+    },
 };
 const POOL_INITIALIZE_TOPIC = '0xdd466e674ea557f56295e2d0218a125ea4b4f0f6f3307b95f85e6110838d6438';
+export function isSafeDiscoveredV4PoolKey(key) {
+    return key.fee >= 0 && key.fee <= V4_DISCOVERY_MAX_LP_FEE;
+}
 export function computeV4PoolId(key) {
     return keccak256(AbiCoder.defaultAbiCoder().encode(['address', 'address', 'uint24', 'int24', 'address'], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
 }
@@ -73,6 +81,19 @@ async function resolvePoolKey(chainId, poolId, provider) {
     const log = logs[0];
     if (!log)
         return null;
+    const key = poolKeyFromInitializeLog(log);
+    if (!key)
+        return null;
+    if (computeV4PoolId(key).toLowerCase() !== poolId.toLowerCase()) {
+        return null;
+    }
+    poolKeyCache.set(cacheKey, key);
+    return key;
+}
+function poolKeyFromInitializeLog(log) {
+    const poolId = log.topics[1];
+    if (!poolId || !log.topics[2] || !log.topics[3])
+        return null;
     const [fee, tickSpacing, hooks] = AbiCoder.defaultAbiCoder().decode(['uint24', 'int24', 'address', 'uint160', 'int24'], log.data);
     const key = {
         currency0: '0x' + log.topics[2].slice(26),
@@ -84,7 +105,6 @@ async function resolvePoolKey(chainId, poolId, provider) {
     if (computeV4PoolId(key).toLowerCase() !== poolId.toLowerCase()) {
         return null;
     }
-    poolKeyCache.set(cacheKey, key);
     return key;
 }
 const discoveryCache = new Map();
@@ -112,7 +132,13 @@ export async function discoverV4Paths(chainId, tokenIn, tokenOut, provider, endp
 async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpoint, cachedPaths) {
     const config = V4_CHAIN_CONFIG[chainId];
     const { tokens } = getGuruProtocolAddresses(chainId);
-    const majors = [tokens.WETH, tokens.USDC, tokens.USDT, V4_ZERO_ADDRESS];
+    const majors = [
+        tokens.WETH,
+        tokens.USDC,
+        tokens.USDT,
+        tokens.USDG,
+        V4_ZERO_ADDRESS,
+    ].filter((token) => Boolean(token));
     const isMajor = (token) => majors.some((major) => compareAddresses(major, token));
     const queryOrder = isMajor(tokenIn) ? [tokenOut, tokenIn] : [tokenIn, tokenOut];
     let poolIds = [];
@@ -127,7 +153,12 @@ async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpo
             break;
     }
     const keys = await Promise.all(poolIds.map((poolId) => resolvePoolKey(chainId, poolId, provider)));
-    const paths = keys
+    const resolvedKeys = keys.filter((key) => key !== null && isSafeDiscoveredV4PoolKey(key));
+    const onchainKeys = resolvedKeys.length > 0
+        ? []
+        : await discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provider);
+    const paths = resolvedKeys
+        .concat(onchainKeys)
         .filter((key) => key !== null)
         .map((key) => [
         {
@@ -141,6 +172,27 @@ async function discoverDirectV4Paths(chainId, tokenIn, tokenOut, provider, endpo
     ]);
     return paths;
 }
+async function discoverOnchainDirectV4PoolKeys(chainId, tokenIn, tokenOut, provider) {
+    const config = V4_CHAIN_CONFIG[chainId];
+    const [currency0, currency1] = tokenIn.toLowerCase() < tokenOut.toLowerCase()
+        ? [tokenIn, tokenOut]
+        : [tokenOut, tokenIn];
+    const logs = await provider.getLogs({
+        address: config.poolManager,
+        topics: [
+            POOL_INITIALIZE_TOPIC,
+            null,
+            zeroPadValue(currency0, 32),
+            zeroPadValue(currency1, 32),
+        ],
+        fromBlock: config.deployBlock,
+        toBlock: 'latest',
+    });
+    return logs
+        .map(poolKeyFromInitializeLog)
+        .filter((key) => key !== null && isSafeDiscoveredV4PoolKey(key))
+        .sort((a, b) => a.fee - b.fee);
+}
 export function _clearV4DiscoveryCache() {
     discoveryCache.clear();
     poolKeyCache.clear();

package/dist/schemas/index.d.ts

@@ -3,4 +3,5 @@ export { quoteDepositSchema } from './quoteDeposit';
 export { quoteWithdrawalSchema } from './quoteWithdrawal';
 export { quoteTradeSchema } from './quoteTrade';
 export { quoteHarvestSchema } from './quoteHarvest';
+export { quoteCloseSchema } from './quoteClose';
 export { quoteRebalanceSchema } from './quoteRebalance';

package/dist/schemas/index.js

@@ -3,4 +3,5 @@ export { quoteDepositSchema } from './quoteDeposit.js';
 export { quoteWithdrawalSchema } from './quoteWithdrawal.js';
 export { quoteTradeSchema } from './quoteTrade.js';
 export { quoteHarvestSchema } from './quoteHarvest.js';
+export { quoteCloseSchema } from './quoteClose.js';
 export { quoteRebalanceSchema } from './quoteRebalance.js';

package/dist/schemas/quoteClose.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const quoteCloseSchema: z.ZodObject<{
+    ledger: z.ZodString;
+    coin: z.ZodString;
+    slippageSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>>;
+}, "strip", z.ZodTypeAny, {
+    ledger: string;
+    coin: string;
+    slippageSettings?: Record<string, bigint> | undefined;
+}, {
+    ledger: string;
+    coin: string;
+    slippageSettings?: Record<string, string | number | bigint> | undefined;
+}>;

package/dist/schemas/quoteClose.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { slippageSettingsRecord } from './primitives.js';
+export const quoteCloseSchema = z.object({
+    ledger: z.string(),
+    coin: z.string(),
+    slippageSettings: slippageSettingsRecord(),
+});

package/dist/txBuilders/buildCloseTx.d.ts

@@ -0,0 +1,14 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface BuildCloseTxParams {
+    controller: string;
+    ledger: string;
+    coin: string;
+    extCalls: ExternalCallStruct[];
+    from: string;
+}
+export default function buildCloseTx(params: BuildCloseTxParams): TransactionRequest;
+export {};

package/dist/txBuilders/buildCloseTx.js

@@ -0,0 +1,15 @@
+import { FundController__factory } from '../typechain/index.js';
+export default function buildCloseTx(params) {
+    const data = FundController__factory.createInterface().encodeFunctionData('closeFund', [
+        {
+            ledger: params.ledger,
+            coin: params.coin,
+            extCalls: params.extCalls,
+        },
+    ]);
+    return {
+        to: params.controller,
+        from: params.from,
+        data,
+    };
+}

package/dist/txBuilders/index.d.ts

@@ -1,5 +1,7 @@
 export { default as buildDepositTx } from './buildDepositTx';
 export type { BuildDepositTxParams } from './buildDepositTx';
+export { default as buildCloseTx } from './buildCloseTx';
+export type { BuildCloseTxParams } from './buildCloseTx';
 export { default as buildWithdrawTx } from './buildWithdrawTx';
 export type { BuildWithdrawTxParams } from './buildWithdrawTx';
 export { default as buildHarvestTx } from './buildHarvestTx';

package/dist/txBuilders/index.js

@@ -1,4 +1,5 @@
 export { default as buildDepositTx } from './buildDepositTx.js';
+export { default as buildCloseTx } from './buildCloseTx.js';
 export { default as buildWithdrawTx } from './buildWithdrawTx.js';
 export { default as buildHarvestTx } from './buildHarvestTx.js';
 export { default as buildTradeTx } from './buildTradeTx.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@guru-fund/sdk",
-    "version": "0.2.6",
+    "version": "0.2.8",
     "description": "Guru Protocol SDK — quote + transaction builders for on-chain managed funds.",
     "license": "MIT",
     "type": "module",