@guru-fund/sdk 0.1.0

package/dist/router/pathCache.js

@@ -0,0 +1,116 @@
+import compareAddresses from '../helpers/compareAddresses.js';
+import { VELORA_ENDPOINT, VELORA_NEGATIVE_CACHE_TTL, VELORA_PATH_CACHE_TTL, VELORA_VERSION_BY_DEX, } from './constants.js';
+export function extractPathFromResponse(dex, response) {
+    if (dex === 'UniswapV4') {
+        return extractV4Path(response);
+    }
+    if (dex === 'UniswapV2' || dex === 'PancakeSwapV2') {
+        const v2Response = response;
+        const path = v2Response.priceRoute.bestRoute[0].swaps[0].swapExchanges[0]
+            .data.path;
+        return { type: 'v2', path, hops: path.length - 1 };
+    }
+    const v3Response = response;
+    const swaps = v3Response.priceRoute.bestRoute[0].swaps;
+    const combinedPath = [];
+    for (const swap of swaps) {
+        const swapPath = swap.swapExchanges[0].data.path;
+        if (!Array.isArray(swapPath) ||
+            typeof swapPath[0]?.tokenIn !== 'string' ||
+            typeof swapPath[0]?.fee !== 'string') {
+            throw new Error('Unexpected V3 path structure');
+        }
+        combinedPath.push(...swapPath);
+    }
+    return { type: 'v3', path: combinedPath, hops: combinedPath.length };
+}
+function toV4PathHop(hop) {
+    return {
+        tokenIn: hop.tokenIn,
+        tokenOut: hop.tokenOut,
+        fee: Number(hop.pool.key.fee),
+        tickSpacing: hop.pool.key.tickSpacing,
+        hooks: hop.pool.key.hooks,
+        hookData: '0x',
+    };
+}
+export function extractV4Path(response) {
+    const swaps = response.priceRoute.bestRoute[0].swaps;
+    const legs = swaps.map((swap) => [...swap.swapExchanges].sort((a, b) => b.percent - a.percent));
+    const combinedPath = [];
+    const tryLeg = (index, previousOut) => {
+        if (index === legs.length)
+            return true;
+        for (const exchange of legs[index]) {
+            const hops = exchange.data.path;
+            if (!Array.isArray(hops) || hops.length === 0)
+                continue;
+            if (typeof hops[0]?.tokenIn !== 'string' || !hops[0]?.pool?.key) {
+                throw new Error('Unexpected V4 path structure');
+            }
+            if (previousOut !== null &&
+                !compareAddresses(hops[0].tokenIn, previousOut)) {
+                continue;
+            }
+            combinedPath.push(...hops.map(toV4PathHop));
+            if (tryLeg(index + 1, hops[hops.length - 1].tokenOut))
+                return true;
+            combinedPath.length -= hops.length;
+        }
+        return false;
+    };
+    if (!tryLeg(0, null)) {
+        throw new Error('Unexpected V4 path structure');
+    }
+    const first = combinedPath[0];
+    const last = combinedPath[combinedPath.length - 1];
+    if (!compareAddresses(first.tokenIn, response.priceRoute.srcToken) ||
+        !compareAddresses(last.tokenOut, response.priceRoute.destToken)) {
+        throw new Error('Unexpected V4 path structure');
+    }
+    return { type: 'v4', path: combinedPath, hops: combinedPath.length };
+}
+const pathCache = new Map();
+export async function getPath({ chainId, dex, tokenIn, tokenOut, srcDecimals, destDecimals, vault, }, endpoint = VELORA_ENDPOINT) {
+    const cacheKey = `${chainId}:${dex}:${tokenIn}:${tokenOut}`;
+    const cache = pathCache.get(cacheKey);
+    const ttl = cache?.path
+        ? VELORA_PATH_CACHE_TTL
+        : VELORA_NEGATIVE_CACHE_TTL;
+    const cacheExpired = cache && Date.now() - cache.timestamp > ttl;
+    if (cache && !cacheExpired)
+        return cache.path;
+    const url = new URL(endpoint);
+    url.searchParams.set('network', String(chainId));
+    url.searchParams.set('userAddress', vault);
+    url.searchParams.set('srcToken', tokenIn);
+    url.searchParams.set('srcDecimals', srcDecimals.toString());
+    url.searchParams.set('destToken', tokenOut);
+    url.searchParams.set('destDecimals', destDecimals.toString());
+    url.searchParams.set('amount', (10 ** srcDecimals).toString());
+    url.searchParams.set('side', 'SELL');
+    url.searchParams.set('slippage', '100');
+    url.searchParams.set('includeDEXS', dex);
+    const version = VELORA_VERSION_BY_DEX[dex];
+    if (version)
+        url.searchParams.set('version', version);
+    let response = await fetch(url.toString());
+    if (!response.ok && (response.status === 429 || response.status >= 500)) {
+        await new Promise((r) => setTimeout(r, 300));
+        response = await fetch(url.toString());
+    }
+    if (!response.ok) {
+        pathCache.set(cacheKey, { path: false, timestamp: Date.now() });
+        return false;
+    }
+    const veloraResponse = (await response.json());
+    const extractedPath = extractPathFromResponse(dex, veloraResponse);
+    pathCache.set(cacheKey, {
+        path: extractedPath,
+        timestamp: Date.now(),
+    });
+    return extractedPath;
+}
+export function _clearPathCache() {
+    pathCache.clear();
+}

package/dist/router/poolHelper.d.ts

@@ -0,0 +1,126 @@
+import { BytesLike, type Provider } from 'ethers';
+import { type GuruProtocolAddresses, type GuruProtocolChainId } from '../addresses';
+import type { SwapAeroV2Struct } from '../typechain/out/AerodromeV2Adapter';
+import type { SwapV2Struct } from '../typechain/out/UniswapV2Adapter';
+import type { SwapV3Struct } from '../typechain/out/UniswapV3Adapter';
+import type { PrefixTx, SwapSimulator } from './simulation';
+export declare const SwapType: Readonly<{
+    EXACT_INPUT: 0n;
+    EXACT_OUTPUT: 1n;
+}>;
+export type SwapType = (typeof SwapType)[keyof typeof SwapType];
+export type FeeTier = 0 | 1 | 50 | 100 | 200 | 500 | 2500 | 3000 | 10000;
+export type AeroRoute = {
+    from: string;
+    to: string;
+    stable: boolean;
+    factory: string;
+};
+type V2DexData = {
+    type: 'v2';
+    router: string;
+    kind: 'uniswap' | 'aerodrome';
+    swappable: boolean;
+};
+type V3DexData = {
+    type: 'v3';
+    router?: string;
+    quoter: string;
+    feeTiers: number[];
+    kind: 'uniswap' | 'aerodrome';
+    swappable: boolean;
+};
+type DexData = V2DexData | V3DexData;
+export type Pool = {
+    address: string;
+    feeTier: FeeTier;
+    exchangeFactory: string;
+    wethBalance: bigint;
+};
+type Quote = {
+    feeTier: FeeTier;
+    amount: bigint;
+    swapFee: bigint;
+    router: string;
+    exchangeFactory: string;
+    poolAddress?: string;
+    tickSpacing?: bigint;
+};
+export type QuoteRequest = {
+    swapType?: SwapType;
+    tokenAmount: bigint;
+    slippage?: bigint;
+    path: [string, string];
+    requireSwappable?: boolean;
+};
+type VersionSpecificQuoteRequest = Omit<QuoteRequest, 'path' | 'slippage'> & {
+    exchangeFactory: string;
+    feeTier: FeeTier;
+    path: [string, string];
+    slippage: bigint;
+    poolAddress?: string;
+};
+export type StableQuoteRequest = {
+    path: [string, string, string];
+    inputAmount: bigint;
+    slippage: bigint;
+    exchangeFactory: string;
+    finalization?: PoolRouteFinalizationContext;
+};
+export type StableQuoteResult = {
+    adapter: string;
+    data: SwapV2Struct | SwapV3Struct | SwapAeroV2Struct;
+    callData: BytesLike;
+    toll: {
+        currency: string;
+        amount: bigint;
+    };
+    effectiveSlippageBps?: string;
+};
+export interface PoolRouteFinalizationContext {
+    blockNumber: number;
+    controller: string;
+    vault: string;
+    account: string;
+    simulator: SwapSimulator;
+    prefixTxs?: PrefixTx[];
+    maxSlippageE3?: bigint;
+}
+export default class PoolHelper {
+    readonly chainId: GuruProtocolChainId;
+    readonly addresses: GuruProtocolAddresses;
+    protected readonly provider: Provider;
+    private readonly getSwapFeePercentage;
+    private readonly dexTable;
+    private readonly poolsCache;
+    constructor(config: {
+        chainId: number;
+        provider: Provider;
+        getSwapFeePercentage: () => Promise<bigint>;
+    });
+    private _finalizeExecutableQuote;
+    getDexData(exchangeFactory: string): DexData;
+    isAerodrome(exchangeFactory: string): boolean;
+    getPoolFeeTier(poolAddress: string): Promise<FeeTier>;
+    private _getPoolsFromOnChainQuery;
+    getUniswapCompatibleTokenPools(token: string, options?: {
+        type?: 'v2' | 'v3';
+        exchangeFactory?: string;
+        swappableOnly?: boolean;
+    }): Promise<Pool[]>;
+    getUniswapCompatibleTokenPool(token: string, options?: {
+        type?: 'v2' | 'v3';
+        exchangeFactory?: string;
+        swappableOnly?: boolean;
+    }): Promise<Pool>;
+    getBestQuote({ swapType, tokenAmount, slippage, path, requireSwappable, }: QuoteRequest): Promise<Quote>;
+    getV2Quote({ swapType, tokenAmount, exchangeFactory, path, feeTier, slippage, }: VersionSpecificQuoteRequest): Promise<Quote>;
+    getV3Quote({ swapType, tokenAmount, exchangeFactory, path, feeTier, slippage, poolAddress, }: VersionSpecificQuoteRequest): Promise<Quote>;
+    getStableForTokenQuote({ path, inputAmount, slippage, exchangeFactory, finalization, }: StableQuoteRequest): Promise<StableQuoteResult>;
+    private _quoteV3MultiHop;
+    getTokensForStableQuote({ path, inputAmount, slippage, exchangeFactory, finalization, }: StableQuoteRequest): Promise<StableQuoteResult>;
+    getLotusAdapter(exchangeFactory: string): string;
+    private _adjustTokenAmountForSwapFee;
+    private _adjustQuoteForSwapFeeAndSlippage;
+}
+export {};