@ring-protocol/smart-order-router 0.5.0

package/build/module/providers/caching-subgraph-provider.d.ts

@@ -0,0 +1,33 @@
+import { Protocol } from '@ring-protocol/router-sdk';
+import { ChainId, Currency, Token } from '@ring-protocol/sdk-core';
+import { SubgraphPool } from '../routers/alpha-router/functions/get-candidate-pools';
+import { ICache } from './cache';
+import { ProviderConfig } from './provider';
+import { V3SubgraphPool } from './v3/subgraph-provider';
+declare type ChainTokenList = {
+    readonly [chainId in ChainId]: Currency[];
+};
+export declare const BASES_TO_CHECK_TRADES_AGAINST: ChainTokenList;
+export interface IV3SubgraphProvider {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<V3SubgraphPool[]>;
+}
+export interface ISubgraphProvider<TSubgraphPool extends SubgraphPool> {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+}
+export declare abstract class CachingSubgraphProvider<TSubgraphPool extends SubgraphPool> implements ISubgraphProvider<TSubgraphPool> {
+    private chainId;
+    protected subgraphProvider: ISubgraphProvider<TSubgraphPool>;
+    private cache;
+    private protocol;
+    private SUBGRAPH_KEY;
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     * @param protocol Subgraph protocol version
+     */
+    constructor(chainId: ChainId, subgraphProvider: ISubgraphProvider<TSubgraphPool>, cache: ICache<TSubgraphPool[]>, protocol: Protocol);
+    getPools(): Promise<TSubgraphPool[]>;
+}
+export {};

package/build/module/providers/caching-subgraph-provider.js

@@ -0,0 +1,182 @@
+import { ChainId } from '@ring-protocol/sdk-core';
+import { nativeOnChain, WRAPPED_NATIVE_CURRENCY } from '../util';
+import { ARB_ARBITRUM, BTC_BNB, BUSD_BNB, CELO, CEUR_CELO, CUSD_CELO, DAI_ARBITRUM, DAI_AVAX, DAI_BNB, DAI_CELO, DAI_MAINNET, DAI_MOONBEAM, DAI_OPTIMISM, DAI_UNICHAIN, ETH_BNB, OP_OPTIMISM, SUSD_STORY_ODYSSEY, USDB_BLAST, USDB_BLAST_SEPOLIA, USDC_ARBITRUM, USDC_AVAX, USDC_BASE, USDC_BASE_SEPOLIA, USDC_BNB, USDC_MAINNET, USDC_MONAD, USDC_MOONBEAM, USDC_NATIVE_ARBITRUM, USDC_OPTIMISM, USDC_POLYGON, USDC_SEPOLIA, USDC_SONEIUM, USDC_STORY_MAINNET, USDC_UNICHAIN, USDC_UNICHAIN_SEPOLIA, USDC_WORLDCHAIN, USDC_ZKSYNC, USDCE_ZKSYNC, USDT_ARBITRUM, USDT_BNB, USDT_HYPER_MAINNET, USDT_MAINNET, USDT_MONAD_TESTNET, USDT_OPTIMISM, WBTC_ARBITRUM, WBTC_MAINNET, WBTC_MOONBEAM, WBTC_OPTIMISM, WBTC_WORLDCHAIN, WETH_POLYGON, WLD_WORLDCHAIN, WMATIC_POLYGON, WSTETH_MAINNET, } from './token-provider';
+export const BASES_TO_CHECK_TRADES_AGAINST = {
+    [ChainId.HYPER_MAINNET]: [
+        nativeOnChain(ChainId.HYPER_MAINNET),
+        WRAPPED_NATIVE_CURRENCY[ChainId.HYPER_MAINNET],
+        USDT_HYPER_MAINNET,
+    ],
+    [ChainId.MAINNET]: [
+        nativeOnChain(ChainId.MAINNET),
+        WRAPPED_NATIVE_CURRENCY[ChainId.MAINNET],
+        DAI_MAINNET,
+        USDC_MAINNET,
+        USDT_MAINNET,
+        WBTC_MAINNET,
+        WSTETH_MAINNET,
+    ],
+    [ChainId.GOERLI]: [WRAPPED_NATIVE_CURRENCY[ChainId.GOERLI]],
+    [ChainId.SEPOLIA]: [
+        nativeOnChain(ChainId.SEPOLIA),
+        WRAPPED_NATIVE_CURRENCY[ChainId.SEPOLIA],
+        USDC_SEPOLIA,
+    ],
+    //v2 not deployed on [arbitrum, polygon, celo, gnosis, moonbeam, bnb, avalanche] and their testnets
+    [ChainId.OPTIMISM]: [
+        nativeOnChain(ChainId.OPTIMISM),
+        WRAPPED_NATIVE_CURRENCY[ChainId.OPTIMISM],
+        USDC_OPTIMISM,
+        DAI_OPTIMISM,
+        USDT_OPTIMISM,
+        WBTC_OPTIMISM,
+        OP_OPTIMISM,
+    ],
+    [ChainId.ARBITRUM_ONE]: [
+        nativeOnChain(ChainId.ARBITRUM_ONE),
+        WRAPPED_NATIVE_CURRENCY[ChainId.ARBITRUM_ONE],
+        WBTC_ARBITRUM,
+        DAI_ARBITRUM,
+        USDC_ARBITRUM,
+        USDC_NATIVE_ARBITRUM,
+        USDT_ARBITRUM,
+        ARB_ARBITRUM,
+    ],
+    [ChainId.ARBITRUM_GOERLI]: [],
+    [ChainId.ARBITRUM_SEPOLIA]: [],
+    [ChainId.OPTIMISM_GOERLI]: [],
+    [ChainId.OPTIMISM_SEPOLIA]: [],
+    [ChainId.POLYGON]: [
+        nativeOnChain(ChainId.POLYGON),
+        USDC_POLYGON,
+        WETH_POLYGON,
+        WMATIC_POLYGON,
+    ],
+    [ChainId.POLYGON_MUMBAI]: [],
+    [ChainId.CELO]: [CELO, CUSD_CELO, CEUR_CELO, DAI_CELO],
+    [ChainId.CELO_ALFAJORES]: [],
+    [ChainId.GNOSIS]: [],
+    [ChainId.MOONBEAM]: [
+        WRAPPED_NATIVE_CURRENCY[ChainId.MOONBEAM],
+        DAI_MOONBEAM,
+        USDC_MOONBEAM,
+        WBTC_MOONBEAM,
+    ],
+    [ChainId.BNB]: [
+        nativeOnChain(ChainId.BNB),
+        WRAPPED_NATIVE_CURRENCY[ChainId.BNB],
+        BUSD_BNB,
+        DAI_BNB,
+        USDC_BNB,
+        USDT_BNB,
+        BTC_BNB,
+        ETH_BNB,
+    ],
+    [ChainId.AVALANCHE]: [
+        WRAPPED_NATIVE_CURRENCY[ChainId.AVALANCHE],
+        USDC_AVAX,
+        DAI_AVAX,
+    ],
+    [ChainId.BASE_GOERLI]: [],
+    [ChainId.BASE]: [
+        nativeOnChain(ChainId.BASE),
+        WRAPPED_NATIVE_CURRENCY[ChainId.BASE],
+        USDC_BASE,
+    ],
+    [ChainId.ZORA]: [
+        nativeOnChain(ChainId.ZORA),
+        WRAPPED_NATIVE_CURRENCY[ChainId.ZORA],
+    ],
+    [ChainId.ZORA_SEPOLIA]: [WRAPPED_NATIVE_CURRENCY[ChainId.ZORA_SEPOLIA]],
+    [ChainId.ROOTSTOCK]: [WRAPPED_NATIVE_CURRENCY[ChainId.ROOTSTOCK]],
+    [ChainId.BLAST]: [
+        nativeOnChain(ChainId.BLAST),
+        WRAPPED_NATIVE_CURRENCY[ChainId.BLAST],
+        USDB_BLAST,
+    ],
+    [ChainId.ZKSYNC]: [
+        WRAPPED_NATIVE_CURRENCY[ChainId.ZKSYNC],
+        USDCE_ZKSYNC,
+        USDC_ZKSYNC,
+    ],
+    [ChainId.WORLDCHAIN]: [
+        nativeOnChain(ChainId.WORLDCHAIN),
+        WRAPPED_NATIVE_CURRENCY[ChainId.WORLDCHAIN],
+        USDC_WORLDCHAIN,
+        WLD_WORLDCHAIN,
+        WBTC_WORLDCHAIN,
+    ],
+    [ChainId.UNICHAIN_SEPOLIA]: [
+        nativeOnChain(ChainId.UNICHAIN_SEPOLIA),
+        WRAPPED_NATIVE_CURRENCY[ChainId.UNICHAIN_SEPOLIA],
+        USDC_UNICHAIN_SEPOLIA,
+    ],
+    [ChainId.UNICHAIN]: [
+        nativeOnChain(ChainId.UNICHAIN),
+        WRAPPED_NATIVE_CURRENCY[ChainId.UNICHAIN],
+        DAI_UNICHAIN,
+        USDC_UNICHAIN,
+    ],
+    [ChainId.BASE_SEPOLIA]: [
+        nativeOnChain(ChainId.BASE_SEPOLIA),
+        WRAPPED_NATIVE_CURRENCY[ChainId.BASE_SEPOLIA],
+        USDC_BASE_SEPOLIA,
+    ],
+    [ChainId.MONAD_TESTNET]: [
+        nativeOnChain(ChainId.MONAD_TESTNET),
+        WRAPPED_NATIVE_CURRENCY[ChainId.MONAD_TESTNET],
+        USDT_MONAD_TESTNET,
+    ],
+    [ChainId.SONEIUM]: [
+        nativeOnChain(ChainId.SONEIUM),
+        WRAPPED_NATIVE_CURRENCY[ChainId.SONEIUM],
+        USDC_SONEIUM,
+    ],
+    [ChainId.MONAD]: [
+        nativeOnChain(ChainId.MONAD),
+        WRAPPED_NATIVE_CURRENCY[ChainId.MONAD],
+        USDC_MONAD,
+    ],
+    // networks exclusive to ring swap
+    [ChainId.BLAST_SEPOLIA]: [
+        nativeOnChain(ChainId.BLAST_SEPOLIA),
+        WRAPPED_NATIVE_CURRENCY[ChainId.BLAST_SEPOLIA],
+        USDB_BLAST_SEPOLIA,
+    ],
+    [ChainId.STORY_ODYSSEY]: [
+        nativeOnChain(ChainId.STORY_ODYSSEY),
+        WRAPPED_NATIVE_CURRENCY[ChainId.STORY_ODYSSEY],
+        SUSD_STORY_ODYSSEY,
+    ],
+    [ChainId.STORY_MAINNET]: [
+        nativeOnChain(ChainId.STORY_MAINNET),
+        WRAPPED_NATIVE_CURRENCY[ChainId.STORY_MAINNET],
+        USDC_STORY_MAINNET,
+    ],
+};
+export class CachingSubgraphProvider {
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     * @param protocol Subgraph protocol version
+     */
+    constructor(chainId, subgraphProvider, cache, protocol) {
+        this.chainId = chainId;
+        this.subgraphProvider = subgraphProvider;
+        this.cache = cache;
+        this.protocol = protocol;
+        this.SUBGRAPH_KEY = (chainId) => `subgraph-pools-${this.protocol}-${chainId}`;
+    }
+    async getPools() {
+        const cachedPools = await this.cache.get(this.SUBGRAPH_KEY(this.chainId));
+        if (cachedPools) {
+            return cachedPools;
+        }
+        const pools = await this.subgraphProvider.getPools();
+        await this.cache.set(this.SUBGRAPH_KEY(this.chainId), pools);
+        return pools;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/caching-token-list-provider.d.ts

@@ -0,0 +1,52 @@
+import { ChainId, Token } from '@ring-protocol/sdk-core';
+import { TokenList } from '@uniswap/token-lists';
+import { ICache } from './cache';
+import { ITokenProvider, TokenAccessor } from './token-provider';
+/**
+ * Provider for getting token data from a Token List.
+ *
+ * @export
+ * @interface ITokenListProvider
+ */
+export interface ITokenListProvider {
+    hasTokenBySymbol(_symbol: string): Promise<boolean>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    hasTokenByAddress(address: string): Promise<boolean>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+}
+export declare class CachingTokenListProvider implements ITokenProvider, ITokenListProvider {
+    private tokenCache;
+    private CACHE_KEY;
+    private chainId;
+    private chainToTokenInfos;
+    private chainSymbolToTokenInfo;
+    private chainAddressToTokenInfo;
+    private tokenList;
+    private CHAIN_SYMBOL_KEY;
+    private CHAIN_ADDRESS_KEY;
+    /**
+     * Creates an instance of CachingTokenListProvider.
+     * Token metadata (e.g. symbol and decimals) generally don't change so can be cached indefinitely.
+     *
+     * @param chainId The chain id to use.
+     * @param tokenList The token list to get the tokens from.
+     * @param tokenCache Cache instance to hold cached tokens.
+     */
+    constructor(chainId: ChainId | number, tokenList: TokenList, tokenCache: ICache<Token>);
+    static fromTokenListURI(chainId: ChainId | number, tokenListURI: string, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    private static buildTokenList;
+    static fromTokenList(chainId: ChainId | number, tokenList: TokenList, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    /**
+     * If no addresses array is specified, all tokens in the token list are
+     * returned.
+     *
+     * @param _addresses (optional) The token addresses to get.
+     * @returns Promise<TokenAccessor> A token accessor with methods for accessing the tokens.
+     */
+    getTokens(_addresses?: string[]): Promise<TokenAccessor>;
+    hasTokenBySymbol(_symbol: string): Promise<boolean>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    hasTokenByAddress(address: string): Promise<boolean>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+    private buildToken;
+}

package/build/module/providers/caching-token-list-provider.js

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Token } from '@ring-protocol/sdk-core';
+import axios from 'axios';
+import { log } from '../util/log';
+import { metric, MetricLoggerUnit } from '../util/metric';
+export class CachingTokenListProvider {
+    /**
+     * Creates an instance of CachingTokenListProvider.
+     * Token metadata (e.g. symbol and decimals) generally don't change so can be cached indefinitely.
+     *
+     * @param chainId The chain id to use.
+     * @param tokenList The token list to get the tokens from.
+     * @param tokenCache Cache instance to hold cached tokens.
+     */
+    constructor(chainId, tokenList, tokenCache) {
+        this.tokenCache = tokenCache;
+        this.CACHE_KEY = (tokenInfo) => `token-list-token-${this.chainId}/${this.tokenList.name}/${this.tokenList.timestamp}/${this.tokenList.version}/${tokenInfo.address.toLowerCase()}/${tokenInfo.decimals}/${tokenInfo.symbol}/${tokenInfo.name}`;
+        this.CHAIN_SYMBOL_KEY = (chainId, symbol) => `${chainId.toString()}/${symbol}`;
+        this.CHAIN_ADDRESS_KEY = (chainId, address) => `${chainId.toString()}/${address.toLowerCase()}`;
+        this.chainId = chainId;
+        this.tokenList = tokenList;
+        this.chainToTokenInfos = new Map();
+        this.chainSymbolToTokenInfo = new Map();
+        this.chainAddressToTokenInfo = new Map();
+        for (const tokenInfo of this.tokenList.tokens) {
+            const chainId = tokenInfo.chainId;
+            const chainIdString = chainId.toString();
+            const symbol = tokenInfo.symbol;
+            const address = tokenInfo.address.toLowerCase();
+            if (!this.chainToTokenInfos.has(chainIdString)) {
+                this.chainToTokenInfos.set(chainIdString, []);
+            }
+            this.chainToTokenInfos.get(chainIdString).push(tokenInfo);
+            this.chainSymbolToTokenInfo.set(this.CHAIN_SYMBOL_KEY(chainId, symbol), tokenInfo);
+            this.chainAddressToTokenInfo.set(this.CHAIN_ADDRESS_KEY(chainId, address), tokenInfo);
+        }
+    }
+    static async fromTokenListURI(chainId, tokenListURI, tokenCache) {
+        const now = Date.now();
+        const tokenList = await this.buildTokenList(tokenListURI);
+        metric.putMetric('TokenListLoad', Date.now() - now, MetricLoggerUnit.Milliseconds);
+        return new CachingTokenListProvider(chainId, tokenList, tokenCache);
+    }
+    static async buildTokenList(tokenListURI) {
+        log.info(`Getting tokenList from ${tokenListURI}.`);
+        const response = await axios.get(tokenListURI);
+        log.info(`Got tokenList from ${tokenListURI}.`);
+        const { data: tokenList, status } = response;
+        if (status != 200) {
+            log.error({ response }, `Unabled to get token list from ${tokenListURI}.`);
+            throw new Error(`Unable to get token list from ${tokenListURI}`);
+        }
+        return tokenList;
+    }
+    static async fromTokenList(chainId, tokenList, tokenCache) {
+        const now = Date.now();
+        const tokenProvider = new CachingTokenListProvider(chainId, tokenList, tokenCache);
+        metric.putMetric('TokenListLoad', Date.now() - now, MetricLoggerUnit.Milliseconds);
+        return tokenProvider;
+    }
+    /**
+     * If no addresses array is specified, all tokens in the token list are
+     * returned.
+     *
+     * @param _addresses (optional) The token addresses to get.
+     * @returns Promise<TokenAccessor> A token accessor with methods for accessing the tokens.
+     */
+    async getTokens(_addresses) {
+        var _a;
+        const addressToToken = new Map();
+        const symbolToToken = new Map();
+        const addToken = (token) => {
+            if (!token)
+                return;
+            addressToToken.set(token.address.toLowerCase(), token);
+            if (token.symbol !== undefined) {
+                symbolToToken.set(token.symbol.toLowerCase(), token);
+            }
+        };
+        if (_addresses) {
+            for (const address of _addresses) {
+                const token = await this.getTokenByAddress(address);
+                addToken(token);
+            }
+        }
+        else {
+            const chainTokens = (_a = this.chainToTokenInfos.get(this.chainId.toString())) !== null && _a !== void 0 ? _a : [];
+            for (const info of chainTokens) {
+                const token = await this.buildToken(info);
+                addToken(token);
+            }
+        }
+        return {
+            getTokenByAddress: (address) => addressToToken.get(address.toLowerCase()),
+            getTokenBySymbol: (symbol) => symbolToToken.get(symbol.toLowerCase()),
+            getAllTokens: () => {
+                return Array.from(addressToToken.values());
+            },
+        };
+    }
+    async hasTokenBySymbol(_symbol) {
+        return this.chainSymbolToTokenInfo.has(this.CHAIN_SYMBOL_KEY(this.chainId, _symbol));
+    }
+    async getTokenBySymbol(_symbol) {
+        let symbol = _symbol;
+        // We consider ETH as a regular ERC20 Token throughout this package. We don't use the NativeCurrency object from the sdk.
+        // When we build the calldata for swapping we insert wrapping/unwrapping as needed.
+        if (_symbol == 'ETH') {
+            symbol = 'WETH';
+        }
+        const tokenInfo = this.chainSymbolToTokenInfo.get(this.CHAIN_SYMBOL_KEY(this.chainId, symbol));
+        if (!tokenInfo) {
+            return undefined;
+        }
+        const token = await this.buildToken(tokenInfo);
+        return token;
+    }
+    async hasTokenByAddress(address) {
+        return this.chainAddressToTokenInfo.has(this.CHAIN_ADDRESS_KEY(this.chainId, address));
+    }
+    async getTokenByAddress(address) {
+        const tokenInfo = this.chainAddressToTokenInfo.get(this.CHAIN_ADDRESS_KEY(this.chainId, address));
+        if (!tokenInfo) {
+            return undefined;
+        }
+        const token = await this.buildToken(tokenInfo);
+        return token;
+    }
+    async buildToken(tokenInfo) {
+        const cacheKey = this.CACHE_KEY(tokenInfo);
+        const cachedToken = await this.tokenCache.get(cacheKey);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        const token = new Token(this.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
+        await this.tokenCache.set(cacheKey, token);
+        return token;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/caching-token-provider.d.ts

@@ -0,0 +1,24 @@
+import { ChainId, Token } from '@ring-protocol/sdk-core';
+import { ICache } from './cache';
+import { ITokenProvider, TokenAccessor } from './token-provider';
+export declare const CACHE_SEED_TOKENS: {
+    [chainId in ChainId]?: {
+        [symbol: string]: Token;
+    };
+};
+/**
+ * Provider for getting token metadata that falls back to a different provider
+ * in the event of failure.
+ *
+ * @export
+ * @class CachingTokenProviderWithFallback
+ */
+export declare class CachingTokenProviderWithFallback implements ITokenProvider {
+    protected chainId: ChainId;
+    private tokenCache;
+    protected primaryTokenProvider: ITokenProvider;
+    protected fallbackTokenProvider?: ITokenProvider | undefined;
+    private CACHE_KEY;
+    constructor(chainId: ChainId, tokenCache: ICache<Token>, primaryTokenProvider: ITokenProvider, fallbackTokenProvider?: ITokenProvider | undefined);
+    getTokens(_addresses: string[]): Promise<TokenAccessor>;
+}