@cowprotocol/cow-sdk 5.10.2 → 5.11.0-RC.0

package/README.md

@@ -178,6 +178,8 @@ const orderBookApi = new OrderBookApi({
     [SupportedChainId.ARBITRUM]: 'https://YOUR_ENDPOINT/arbitrum_one',
     [SupportedChainId.BASE]: 'https://YOUR_ENDPOINT/base',
     [SupportedChainId.SEPOLIA]: 'https://YOUR_ENDPOINT/sepolia',
+    [SupportedChainId.POLYGON]: 'https://YOUR_ENDPOINT/polygon',
+    [SupportedChainId.AVALANCHE]: 'https://YOUR_ENDPOINT/avalanche',
   },
 })
 ```

package/dist/README.md

@@ -178,6 +178,8 @@ const orderBookApi = new OrderBookApi({
     [SupportedChainId.ARBITRUM]: 'https://YOUR_ENDPOINT/arbitrum_one',
     [SupportedChainId.BASE]: 'https://YOUR_ENDPOINT/base',
     [SupportedChainId.SEPOLIA]: 'https://YOUR_ENDPOINT/sepolia',
+    [SupportedChainId.POLYGON]: 'https://YOUR_ENDPOINT/polygon',
+    [SupportedChainId.AVALANCHE]: 'https://YOUR_ENDPOINT/avalanche',
   },
 })
 ```

package/dist/bridging/BridgingSdk/BridgingSdk.d.ts

@@ -0,0 +1,90 @@
+import { SwapAdvancedSettings, TradingSdk } from '../../trading';
+import { BridgeProvider, BridgeQuoteResult, CrossChainOrder, CrossChainQuoteAndPost, GetErc20Decimals, QuoteBridgeRequest } from '../types';
+import { CowEnv, TokenInfo } from '../../common';
+import { ChainInfo, SupportedChainId, TargetChainId } from '../../chains';
+import { OrderBookApi } from 'src/order-book';
+export interface BridgingSdkOptions {
+    /**
+     * Providers for the bridging.
+     */
+    providers: BridgeProvider<BridgeQuoteResult>[];
+    /**
+     * Function to get the decimals of the ERC20 tokens
+     */
+    getErc20Decimals?: GetErc20Decimals;
+    /**
+     * Trading SDK.
+     */
+    tradingSdk?: TradingSdk;
+    /**
+     * Order book API.
+     */
+    orderBookApi: OrderBookApi;
+    /**
+     * Enable logging for the bridging SDK.
+     */
+    enableLogging?: boolean;
+}
+/**
+ * Parameters for the `getOrder` method.
+ */
+export interface GetOrderParams {
+    /**
+     * The unique identifier of the order.
+     */
+    orderId: string;
+    /**
+     * The chain ID of the order.
+     */
+    chainId: SupportedChainId;
+    /**
+     * The environment of the order
+     */
+    env?: CowEnv;
+}
+export type BridgingSdkConfig = Required<Omit<BridgingSdkOptions, 'enableLogging' | 'getErc20Decimals'>> & Pick<BridgingSdkOptions, 'getErc20Decimals'>;
+/**
+ * SDK for bridging for swapping tokens between different chains.
+ */
+export declare class BridgingSdk {
+    readonly options: BridgingSdkOptions;
+    protected config: BridgingSdkConfig;
+    constructor(options: BridgingSdkOptions);
+    private get provider();
+    /**
+     * Get the providers for the bridging.
+     */
+    getProviders(): BridgeProvider<BridgeQuoteResult>[];
+    /**
+     * Get the available sources networks for the bridging.
+     */
+    getSourceNetworks(): Promise<ChainInfo[]>;
+    /**
+     * Get the available target networks for the bridging.
+     */
+    getTargetNetworks(): Promise<ChainInfo[]>;
+    /**
+     * Get the available buy tokens for buying in a specific target chain
+     *
+     * @param param
+     * @returns
+     */
+    getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]>;
+    /**
+     * Get quote details, including a callback function to post the order on-chain.
+     *
+     * This method support both, cross-chain swaps and single-chain swap.
+     *
+     * The return type will be either `QuoteAndPost` or `BridgeQuoteAndPost`.
+     *
+     * To safely assert the type in Typescript, you can use:
+     * - `isBridgeQuoteAndPost(result)` utility.
+     * - `isQuoteAndPost(result)` utility.
+     * - `assertIsBridgeQuoteAndPost(result)` assertion.
+     * - `assertIsQuoteAndPost(result)` assertion.
+     *
+     * @throws Error if no path is found
+     */
+    getQuote(quoteBridgeRequest: QuoteBridgeRequest, advancedSettings?: SwapAdvancedSettings): Promise<CrossChainQuoteAndPost>;
+    getOrder(params: GetOrderParams): Promise<CrossChainOrder>;
+}

package/dist/bridging/BridgingSdk/getCrossChainOrder.d.ts

@@ -0,0 +1,14 @@
+import { BridgeProvider, BridgeQuoteResult, CrossChainOrder } from '../types';
+import { SupportedChainId } from '../../chains';
+import { OrderBookApi } from 'src/order-book';
+import { CowEnv } from '../../common';
+/**
+ * Fetch a cross-chain order and its status.
+ */
+export declare function getCrossChainOrder(params: {
+    orderId: string;
+    chainId: SupportedChainId;
+    orderBookApi: OrderBookApi;
+    providers: BridgeProvider<BridgeQuoteResult>[];
+    env: CowEnv;
+}): Promise<CrossChainOrder>;

package/dist/bridging/BridgingSdk/getErc20Decimals.d.ts

@@ -0,0 +1,4 @@
+import { Provider } from '@ethersproject/providers';
+import { Signer } from '@ethersproject/abstract-signer';
+import { GetErc20Decimals } from '../types';
+export declare function factoryGetErc20Decimals(provider: Signer | Provider): GetErc20Decimals;

package/dist/bridging/BridgingSdk/getQuoteWithBridging.d.ts

@@ -0,0 +1,32 @@
+import { SwapAdvancedSettings, TradingSdk } from '../../trading';
+import { BridgeProvider, BridgeQuoteAndPost, BridgeQuoteResult, GetErc20Decimals, QuoteBridgeRequest } from '../types';
+import { SignerLike } from '../../common';
+type GetQuoteWithBridgeParams<T extends BridgeQuoteResult> = {
+    /**
+     * Overall request for the swap and the bridge.
+     */
+    swapAndBridgeRequest: QuoteBridgeRequest;
+    /**
+     * Advanced settings for the swap.
+     */
+    advancedSettings?: SwapAdvancedSettings;
+    /**
+     * Provider for the bridge.
+     */
+    provider: BridgeProvider<T>;
+    /**
+     * Trading SDK.
+     */
+    tradingSdk: TradingSdk;
+    /**
+     * Function to get the decimals of the ERC20 tokens.
+     */
+    getErc20Decimals: GetErc20Decimals;
+    /**
+     * For quote fetching we have to sign bridging hooks.
+     * But we won't do that using users wallet and will use some static PK.
+     */
+    bridgeHookSigner?: SignerLike;
+};
+export declare function getQuoteWithBridge<T extends BridgeQuoteResult>(params: GetQuoteWithBridgeParams<T>): Promise<BridgeQuoteAndPost>;
+export {};

package/dist/bridging/BridgingSdk/getQuoteWithoutBridge.d.ts

@@ -0,0 +1,7 @@
+import { QuoteAndPost, SwapAdvancedSettings, TradingSdk } from '../../trading';
+import { QuoteBridgeRequest } from '../types';
+export declare function getQuoteWithoutBridge(params: {
+    quoteBridgeRequest: QuoteBridgeRequest;
+    advancedSettings?: SwapAdvancedSettings;
+    tradingSdk: TradingSdk;
+}): Promise<QuoteAndPost>;

package/dist/bridging/const.d.ts

@@ -0,0 +1,2 @@
+export declare const RAW_PROVIDERS_FILES_PATH: string;
+export declare const DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION = 110000;

package/dist/bridging/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class BridgeProviderQuoteError extends Error {
+    readonly context: any;
+    constructor(message: string, context: any);
+}

package/dist/bridging/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './errors';
+export * from './utils';
+export * from './BridgingSdk/BridgingSdk';
+export { MockBridgeProvider } from './providers/mock/MockBridgeProvider';
+export { AcrossBridgeProvider, AcrossQuoteResult, AcrossBridgeProviderOptions, } from './providers/across/AcrossBridgeProvider';

package/dist/bridging/providers/across/AcrossApi.d.ts

@@ -0,0 +1,27 @@
+import { AvailableRoutesRequest, Route, SuggestedFeesRequest, SuggestedFeesResponse } from './types';
+export interface AcrossApiOptions {
+    apiBaseUrl?: string;
+}
+export declare class AcrossApi {
+    private readonly options;
+    constructor(options?: AcrossApiOptions);
+    /**
+     * Retrieve available routes for transfers
+     *
+     * Returns available routes based on specified parameters. If no parameters are provided, available routes on all
+     * chains are returned.
+     *
+     * See https://docs.across.to/reference/api-reference#available-routes
+     */
+    getAvailableRoutes({ originChainId, originToken, destinationChainId, destinationToken, }: AvailableRoutesRequest): Promise<Route[]>;
+    /**
+     * Retrieve suggested fee quote for a deposit.
+     *
+     * Returns suggested fees based inputToken+outputToken, originChainId, destinationChainId, and amount.
+     * Also includes data used to compute the fees.
+     *
+     * * See https://docs.across.to/reference/api-reference#suggested-fees
+     */
+    getSuggestedFees(request: SuggestedFeesRequest): Promise<SuggestedFeesResponse>;
+    protected fetchApi<T>(path: string, params: Record<string, string>, isValidResponse?: (response: unknown) => response is T): Promise<T>;
+}

package/dist/bridging/providers/across/AcrossBridgeProvider.d.ts

@@ -0,0 +1,43 @@
+import { Signer } from 'ethers';
+import { latest as latestAppData } from '@cowprotocol/app-data';
+import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, QuoteBridgeRequest } from '../../types';
+import { ChainId, ChainInfo, SupportedChainId, TargetChainId } from '../../../chains';
+import { EvmCall, TokenInfo } from '../../../common';
+import { AcrossApi, AcrossApiOptions } from './AcrossApi';
+import { CowShedSdk, CowShedSdkOptions } from '../../../cow-shed';
+import { SuggestedFeesResponse } from './types';
+export declare const ACROSS_SUPPORTED_NETWORKS: ChainInfo[];
+export interface AcrossBridgeProviderOptions {
+    /**
+     * Token info provider
+     * @param chainId - The chain ID
+     * @param addresses - The addresses of the tokens to get the info for
+     * @returns The token infos
+     */
+    getTokenInfos?: (chainId: ChainId, addresses: string[]) => Promise<TokenInfo[]>;
+    apiOptions?: AcrossApiOptions;
+    cowShedOptions?: CowShedSdkOptions;
+}
+export interface AcrossQuoteResult extends BridgeQuoteResult {
+    suggestedFees: SuggestedFeesResponse;
+}
+export declare class AcrossBridgeProvider implements BridgeProvider<AcrossQuoteResult> {
+    private options;
+    protected api: AcrossApi;
+    protected cowShedSdk: CowShedSdk;
+    constructor(options?: AcrossBridgeProviderOptions);
+    info: BridgeProviderInfo;
+    getNetworks(): Promise<ChainInfo[]>;
+    getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]>;
+    getIntermediateTokens(request: QuoteBridgeRequest): Promise<string[]>;
+    getQuote(request: QuoteBridgeRequest): Promise<AcrossQuoteResult>;
+    getUnsignedBridgeCall(request: QuoteBridgeRequest, quote: AcrossQuoteResult): Promise<EvmCall>;
+    getGasLimitEstimationForHook(_request: QuoteBridgeRequest): number;
+    getSignedHook(chainId: SupportedChainId, unsignedCall: EvmCall, signer: Signer): Promise<BridgeHook>;
+    decodeBridgeHook(_hook: latestAppData.CoWHook): Promise<BridgeDeposit>;
+    getBridgingId(_orderUid: string, _settlementTx: string, _logIndex: number): Promise<string>;
+    getExplorerUrl(bridgingId: string): string;
+    getStatus(_bridgingId: string): Promise<BridgeStatusResult>;
+    getCancelBridgingTx(_bridgingId: string): Promise<EvmCall>;
+    getRefundBridgingTx(_bridgingId: string): Promise<EvmCall>;
+}

package/dist/bridging/providers/across/abi.d.ts

@@ -0,0 +1,154 @@
+export declare const ACROSS_MATH_ABI: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+export declare const ACROSS_SPOKE_POOL_ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: ({
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    } | {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    })[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: ({
+        components: ({
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        } | {
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    } | {
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    })[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    stateMutability: string;
+    type: string;
+    inputs?: undefined;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+})[];

package/dist/bridging/providers/across/const/contracts.d.ts

@@ -0,0 +1,3 @@
+import { TargetChainId } from '../../../../chains';
+export declare const ACROSS_SPOOK_CONTRACT_ADDRESSES: Record<TargetChainId, string | undefined>;
+export declare const ACROSS_MATH_CONTRACT_ADDRESSES: Record<TargetChainId, string | undefined>;

package/dist/bridging/providers/across/const/misc.d.ts

@@ -0,0 +1 @@
+export declare const HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";

package/dist/bridging/providers/across/const/tokens.d.ts

@@ -0,0 +1,11 @@
+import { TargetChainId } from '../../../../chains/types';
+/**
+ * Chain config for Across. Includes all the supported tokens for the chain.
+ */
+export interface AcrossChainConfig {
+    chainId: TargetChainId;
+    tokens: {
+        [name: string]: string | undefined;
+    };
+}
+export declare const ACROSS_TOKEN_MAPPING: Partial<Record<TargetChainId, AcrossChainConfig>>;

package/dist/bridging/providers/across/createAcrossDepositCall.d.ts

@@ -0,0 +1,9 @@
+import { EvmCall } from '../../../common';
+import { CowShedSdk } from '../../../cow-shed';
+import { AcrossQuoteResult } from './AcrossBridgeProvider';
+import { QuoteBridgeRequest } from '../../types';
+export declare function createAcrossDepositCall(params: {
+    request: QuoteBridgeRequest;
+    quote: AcrossQuoteResult;
+    cowShedSdk: CowShedSdk;
+}): EvmCall;

package/dist/bridging/providers/across/types.d.ts

@@ -0,0 +1,169 @@
+import type { TargetChainId } from '../../../chains';
+export interface AvailableRoutesRequest {
+    originChainId: string;
+    originToken: string;
+    destinationChainId: string;
+    destinationToken: string;
+}
+export interface Route {
+    originChainId: string;
+    originToken: string;
+    destinationChainId: string;
+    destinationToken: string;
+    originTokenSymbol: string;
+    destinationTokenSymbol: string;
+}
+export interface SuggestedFeesRequest {
+    token: string;
+    originChainId: TargetChainId;
+    destinationChainId: TargetChainId;
+    /**
+     * Amount of the token to transfer.
+     *
+     * Note that this amount is in the native decimals of the token. So, for WETH, this would be the amount of
+     * human-readable WETH multiplied by 1e18.
+     *
+     * For USDC, you would multiply the number of human-readable USDC by 1e6.
+     *
+     * Example: 1000000000000000000
+     */
+    amount: bigint;
+    /**
+     * Recipient of the deposit. Can be an EOA or a contract. If this is an EOA and message is defined, then the API will throw a 4xx error.
+     *
+     * Example: 0xc186fA914353c44b2E33eBE05f21846F1048bEda
+     */
+    recipient?: string;
+    /**
+     * The quote timestamp used to compute the LP fees. When bridging with across, the user only specifies the quote
+     * timestamp in their transaction. The relayer then determines the utilization at that timestamp to determine the
+     * user's fee. This timestamp must be close (within 10 minutes or so) to the current time on the chain where the
+     * user is depositing funds and it should be <= the current block timestamp on mainnet. This allows the user to know
+     * exactly what LP fee they will pay before sending the transaction.
+     *
+     * If this value isn't provided in the request, the API will assume the latest block timestamp on mainnet.
+     *
+     * Example: 1653547649
+     */
+    timestamp?: number;
+    /**
+     * Optionally override the relayer address used to simulate the fillRelay() call that estimates the gas costs
+     * needed to fill a deposit. This simulation result impacts the returned suggested-fees. The reason to customize the
+     * EOA would be primarily if the recipientAddress is a contract and requires a certain relayer to submit the fill,
+     * or if one specific relayer has the necessary token balance to make the fill.
+     *
+     * Example: 0x428AB2BA90Eba0a4Be7aF34C9Ac451ab061AC010
+     */
+    relayer?: string;
+}
+export interface SuggestedFeesLimits {
+    /**
+     * The minimum deposit size in the tokens' units.
+     *
+     * Note: USDC has 6 decimals, so this value would be the number of USDC multiplied by 1e6. For WETH, that would be 1e18.
+     */
+    minDeposit: string;
+    /**
+     * The maximum deposit size in the tokens' units. Note: The formatting of this number is the same as minDeposit.
+     */
+    maxDeposit: string;
+    /**
+     * The max deposit size that can be relayed "instantly" on the destination chain.
+     *
+     * Instantly means that there is relayer capital readily available and that a relayer is expected to relay within
+     * seconds to 5 minutes of the deposit.
+     */
+    maxDepositInstant: string;
+    /**
+     * The max deposit size that can be relayed with a "short delay" on the destination chain.
+     *
+     * This means that there is relayer capital available on mainnet and that a relayer will immediately begin moving
+     * that capital over the canonical bridge to relay the deposit. Depending on the chain, the time for this can vary.
+     *
+     * Polygon is the worst case where it can take between 20 and 35 minutes for the relayer to receive the funds
+     * and relay.
+     *
+     * Arbitrum is much faster, with a range between 5 and 15 minutes. Note: if the transfer size is greater than this,
+     * the estimate should be between 2-4 hours for a slow relay to be processed from the mainnet pool.
+     */
+    maxDepositShortDelay: string;
+    /**
+     * The recommended deposit size that can be relayed "instantly" on the destination chain.
+     *
+     * Instantly means that there is relayer capital readily available and that a relayer is expected to relay
+     * within seconds to 5 minutes of the deposit. Value is in the smallest unit of the respective token.
+     */
+    recommendedDepositInstant: string;
+}
+export interface SuggestedFeesResponse {
+    /**
+     * Percentage of the transfer amount that should go to the relayer as a fee in total. The value is inclusive of lpFee.pct.
+     *
+     * This is the strongly recommended minimum value to ensure a relayer will perform the transfer under the current
+     * network conditions.
+     *
+     * The value returned in this field is guaranteed to be at least 0.03% in order to meet minimum relayer fee requirements
+     */
+    totalRelayFee: PctFee;
+    /**
+     * The percentage of the transfer amount that should go the relayer as a fee to cover relayer capital costs.
+     */
+    relayerCapitalFee: PctFee;
+    /**
+     * The percentage of the transfer amount that should go the relayer as a fee to cover relayer gas costs.
+     */
+    relayerGasFee: PctFee;
+    /**
+     * The percent of the amount that will go to the LPs as a fee for borrowing their funds.
+     */
+    lpFee: PctFee;
+    /**
+     * The quote timestamp that was used to compute the lpFeePct. To pay the quoted LP fee, the user would need to pass
+     * this quote timestamp to the protocol when sending their bridge transaction.
+     */
+    timestamp: string;
+    /**
+     * Is the input amount below the minimum transfer amount.
+     */
+    isAmountTooLow: boolean;
+    /**
+     * The block used associated with this quote, used to compute lpFeePct.
+     */
+    quoteBlock: string;
+    /**
+     * The contract address of the origin SpokePool.
+     */
+    spokePoolAddress: string;
+    /**
+     * The relayer that is suggested to be set as the exclusive relayer for in the depositV3 call for the fastest fill.
+     *
+     * Note: when set to "0x0000000000000000000000000000000000000000", relayer exclusivity will be disabled.
+     * This value is returned in cases where using an exclusive relayer is not recommended.
+     */
+    exclusiveRelayer: string;
+    /**
+     * The suggested exclusivity period (in seconds) the exclusive relayer should be given to fill before other relayers
+     * are allowed to take the fill. Note: when set to "0", relayer exclusivity will be disabled.
+     *
+     * This value is returned in cases where using an exclusive relayer is not recommended.
+     */
+    exclusivityDeadline: string;
+    /**
+     * The expected time (in seconds) for a fill to be made. Represents 75th percentile of the 7-day rolling average of times (updated daily). Times are dynamic by origin/destination token/chain for a given amount.
+     */
+    estimatedFillTimeSec: string;
+    /**
+     * The recommended deadline (UNIX timestamp in seconds) for the relayer to fill the deposit. After this destination chain timestamp, the fill will revert on the destination chain.
+     */
+    fillDeadline: string;
+    limits: SuggestedFeesLimits;
+}
+export interface PctFee {
+    /**
+     * Note: 1% is represented as 1e16, 100% is 1e18, 50% is 5e17, etc. These values are in the same format that the contract understands.
+     *
+     * Example: 100200000000000
+     */
+    pct: string;
+    total: string;
+}

package/dist/bridging/providers/across/util.d.ts

@@ -0,0 +1,39 @@
+import { QuoteBridgeRequest } from '../../../bridging/types';
+import { TargetChainId } from '../../../chains';
+import { AcrossQuoteResult } from './AcrossBridgeProvider';
+import { AcrossChainConfig } from './const/tokens';
+import { SuggestedFeesResponse } from './types';
+/**
+ * Return the chain configs
+ *
+ * This is a temporary implementation. We should use the Across API to get the intermediate tokens (see this.getAvailableRoutes())
+ */
+export declare function getChainConfigs(sourceChainId: TargetChainId, targetChainId: TargetChainId): {
+    sourceChainConfig: AcrossChainConfig;
+    targetChainConfig: AcrossChainConfig;
+} | undefined;
+export declare function getTokenSymbol(tokenAddress: string, chainConfig: AcrossChainConfig): string | undefined;
+export declare function getTokenAddress(tokenSymbol: string, chainConfig: AcrossChainConfig): string | undefined;
+export declare function toBridgeQuoteResult(request: QuoteBridgeRequest, slippageBps: number, suggestedFees: SuggestedFeesResponse): AcrossQuoteResult;
+/**
+ * pct represents a percentage.
+ *
+ * Note: 1% is represented as 1e16, 100% is 1e18, 50% is 5e17, etc. These values are in the same format that the contract understands.
+ *
+ * Bps is a percentage in basis points (1/100th of a percent). For example, 1% is 100 bps.
+ *
+ * @param pct - The percentage to convert to bps
+ * @returns The percentage in bps
+ * @throws If the percentage is greater than 100% or less than 0%
+ */
+export declare function pctToBps(pct: bigint): number;
+/**
+ * Apply a percentage fee to an amount.
+ *
+ * @param amount - The amount to apply the fee to
+ * @param pct - The percentage fee to apply
+ * @throws If the percentage fee is greater than 100% or less than 0%
+ * @returns The amount after the fee has been applied
+ */
+export declare function applyPctFee(amount: bigint, pct: bigint): bigint;
+export declare function applyBps(amount: bigint, bps: number): bigint;