@cowprotocol/cow-sdk 6.0.0-RC.50 → 6.0.0-RC.53

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

@@ -1,8 +1,9 @@
 import { SwapAdvancedSettings, TradingSdk } from '../../trading';
-import { BridgeProvider, BridgeQuoteResult, CrossChainOrder, CrossChainQuoteAndPost, QuoteBridgeRequest } from '../types';
+import { BridgeProvider, BridgeQuoteResult, BridgeStatusResult, CrossChainOrder, CrossChainQuoteAndPost, QuoteBridgeRequest } from '../types';
 import { CowEnv, TokenInfo } from '../../common';
 import { ChainInfo, SupportedChainId, TargetChainId } from '../../chains';
-import { OrderBookApi } from 'src/order-book';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { OrderBookApi } from '../../order-book';
 export interface BridgingSdkOptions {
     /**
      * Providers for the bridging.
@@ -25,14 +26,18 @@ export interface BridgingSdkOptions {
  * Parameters for the `getOrder` method.
  */
 export interface GetOrderParams {
+    /**
+     * Id of a network where order was settled
+     */
+    chainId: SupportedChainId;
     /**
      * The unique identifier of the order.
      */
     orderId: string;
     /**
-     * The chain ID of the order.
+     * RPC provider to get order transactions details
      */
-    chainId: SupportedChainId;
+    rpcProvider: JsonRpcProvider;
     /**
      * The environment of the order
      */
@@ -61,9 +66,8 @@ export declare class BridgingSdk {
     getTargetNetworks(): Promise<ChainInfo[]>;
     /**
      * Get the available buy tokens for buying in a specific target chain
-     *
-     * @param param
-     * @returns
+  
+     * @param targetChainId
      */
     getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]>;
     /**
@@ -82,5 +86,7 @@ export declare class BridgingSdk {
      * @throws Error if no path is found
      */
     getQuote(quoteBridgeRequest: QuoteBridgeRequest, advancedSettings?: SwapAdvancedSettings): Promise<CrossChainQuoteAndPost>;
-    getOrder(params: GetOrderParams): Promise<CrossChainOrder>;
+    getOrder(params: GetOrderParams): Promise<CrossChainOrder | null>;
+    getOrderBridgingStatus(bridgingId: string, originChainId: SupportedChainId): Promise<BridgeStatusResult>;
+    getProviderFromAppData(fullAppData: string): BridgeProvider<BridgeQuoteResult> | undefined;
 }

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

@@ -0,0 +1,2 @@
+import { BridgeProvider, BridgeQuoteResult } from '../types';
+export declare function findBridgeProviderFromHook(fullAppData: string, providers: BridgeProvider<BridgeQuoteResult>[]): BridgeProvider<BridgeQuoteResult> | undefined;

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

@@ -1,14 +1,18 @@
 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;
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { SupportedChainId } from '../../chains';
+import { OrderBookApi } from '../../order-book';
+interface GetCrossChainOrderParams {
     chainId: SupportedChainId;
+    orderId: string;
+    rpcProvider: JsonRpcProvider;
     orderBookApi: OrderBookApi;
     providers: BridgeProvider<BridgeQuoteResult>[];
     env: CowEnv;
-}): Promise<CrossChainOrder>;
+}
+/**
+ * Fetch a cross-chain order and its status.
+ */
+export declare function getCrossChainOrder(params: GetCrossChainOrderParams): Promise<CrossChainOrder | null>;
+export {};

package/dist/bridging/const.d.ts

@@ -1,2 +1,3 @@
 export declare const RAW_PROVIDERS_FILES_PATH = "https://raw.githubusercontent.com/cowprotocol/cow-sdk/refs/heads/main/src/bridging/providers";
 export declare const DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION = 200000;
+export declare const HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";

package/dist/bridging/errors.d.ts

@@ -2,3 +2,7 @@ export declare class BridgeProviderQuoteError extends Error {
     readonly context: unknown;
     constructor(message: string, context: unknown);
 }
+export declare class BridgeOrderParsingError extends Error {
+    readonly context?: unknown | undefined;
+    constructor(message: string, context?: unknown | undefined);
+}

package/dist/bridging/index.d.ts

@@ -3,3 +3,4 @@ export * from './errors';
 export * from './utils';
 export * from './BridgingSdk/BridgingSdk';
 export { AcrossBridgeProvider, AcrossQuoteResult, AcrossBridgeProviderOptions, } from './providers/across/AcrossBridgeProvider';
+export { BungeeBridgeProvider, BungeeQuoteResult, BungeeBridgeProviderOptions, } from './providers/bungee/BungeeBridgeProvider';

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

@@ -1,4 +1,4 @@
-import { AvailableRoutesRequest, Route, SuggestedFeesRequest, SuggestedFeesResponse } from './types';
+import { AvailableRoutesRequest, DepositStatusRequest, DepositStatusResponse, Route, SuggestedFeesRequest, SuggestedFeesResponse } from './types';
 import { TokenInfo } from '../../../common';
 export interface AcrossApiOptions {
     apiBaseUrl?: string;
@@ -25,5 +25,6 @@ export declare class AcrossApi {
      */
     getSuggestedFees(request: SuggestedFeesRequest): Promise<SuggestedFeesResponse>;
     getSupportedTokens(): Promise<TokenInfo[]>;
+    getDepositStatus(request: DepositStatusRequest): Promise<DepositStatusResponse>;
     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

@@ -1,11 +1,13 @@
 import { Signer } from 'ethers';
 import { latest as latestAppData } from '@cowprotocol/app-data';
-import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, QuoteBridgeRequest } from '../../types';
-import { ChainInfo, SupportedChainId, TargetChainId } from '../../../chains';
+import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, BridgingDepositParams, 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';
+import { JsonRpcProvider } from '@ethersproject/providers';
+export declare const ACROSS_HOOK_DAPP_ID = "cow-sdk://bridging/providers/across";
 export declare const ACROSS_SUPPORTED_NETWORKS: ChainInfo[];
 export interface AcrossBridgeProviderOptions {
     apiOptions?: AcrossApiOptions;
@@ -28,9 +30,9 @@ export declare class AcrossBridgeProvider implements BridgeProvider<AcrossQuoteR
     getGasLimitEstimationForHook(_request: QuoteBridgeRequest): number;
     getSignedHook(chainId: SupportedChainId, unsignedCall: EvmCall, signer: Signer, defaultGasLimit?: bigint): Promise<BridgeHook>;
     decodeBridgeHook(_hook: latestAppData.CoWHook): Promise<BridgeDeposit>;
-    getBridgingId(_orderUid: string, _settlementTx: string, _logIndex: number): Promise<string>;
+    getBridgingParams(chainId: ChainId, provider: JsonRpcProvider, orderUid: string, txHash: string): Promise<BridgingDepositParams | null>;
     getExplorerUrl(bridgingId: string): string;
-    getStatus(_bridgingId: string): Promise<BridgeStatusResult>;
+    getStatus(bridgingId: string, originChainId: SupportedChainId): Promise<BridgeStatusResult>;
     getCancelBridgingTx(_bridgingId: string): Promise<EvmCall>;
     getRefundBridgingTx(_bridgingId: string): Promise<EvmCall>;
     private getSupportedTokensState;

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

@@ -0,0 +1,3 @@
+import { Interface } from 'ethers/lib/utils';
+export declare const ACROSS_DEPOSIT_EVENT_INTERFACE: Interface;
+export declare const COW_TRADE_EVENT_INTERFACE: Interface;

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

@@ -1 +1,2 @@
-export declare const HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";
+export declare const ACROSS_DEPOSIT_EVENT_TOPIC: string;
+export declare const COW_TRADE_EVENT_TOPIC: string;

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

@@ -0,0 +1,4 @@
+import { TransactionReceipt } from '@ethersproject/abstract-provider';
+import { SupportedChainId } from '../../../chains';
+import { BridgingDepositParams } from '../../types';
+export declare function getDepositParams(chainId: SupportedChainId, orderId: string, txReceipt: TransactionReceipt): Promise<BridgingDepositParams | null>;

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

@@ -167,3 +167,76 @@ export interface PctFee {
     pct: string;
     total: string;
 }
+export interface DepositStatusRequest {
+    originChainId: string;
+    depositId: string;
+}
+export interface DepositStatusResponse {
+    /**
+     * Status of the deposit:
+     * - filled: Deposit has been filled on destination chain (FilledV3Relay event emitted)
+     * - pending: Deposit not yet filled
+     * - expired: Deposit expired and will be refunded
+     * - refunded: Deposit expired and depositor refunded on originChain
+     * - slowFillRequested: Across' relayer fills without requiring another relayer to front capital
+     *   (requires input token and output token to be the same asset)
+     */
+    status: 'filled' | 'pending' | 'expired' | 'refunded' | 'slowFillRequested';
+    /**
+     * Origin chain ID where the deposit was made.
+     */
+    originChainId: string;
+    /**
+     * Unique identifier of the deposit.
+     */
+    depositId: string;
+    /**
+     * Transaction hash of the deposit on the origin chain.
+     */
+    depositTxHash?: string;
+    /**
+     * Transaction hash of the fill on the destination chain.
+     * Only present when fillStatus is 'filled'.
+     */
+    fillTx?: string;
+    /**
+     * Destination chain ID where the fill transaction will occur.
+     */
+    destinationChainId?: string;
+    /**
+     * Transaction hash of the refund on the origin chain.
+     * Only present when fillStatus is 'refunded'.
+     */
+    depositRefundTxHash?: string;
+    /**
+     * Pagination information for the response.
+     */
+    pagination?: {
+        currentIndex: number;
+        maxIndex: number;
+    };
+}
+export interface AcrossDepositEvent {
+    inputToken: string;
+    outputToken: string;
+    inputAmount: string;
+    outputAmount: string;
+    destinationChainId: string;
+    depositId: string;
+    quoteTimestamp: string;
+    fillDeadline: string;
+    exclusivityDeadline: string;
+    depositor: string;
+    recipient: string;
+    exclusiveRelayer: string;
+    message: string;
+}
+export interface CowTradeEvent {
+    owner: string;
+    sellToken: string;
+    buyToken: string;
+    sellAmount: string;
+    buyAmount: string;
+    feeAmount: string;
+    orderUid: string;
+}

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

@@ -1,8 +1,9 @@
-import { QuoteBridgeRequest } from '../../../bridging/types';
-import { TargetChainId } from '../../../chains';
+import { Log } from '@ethersproject/providers';
+import { BridgeStatus, QuoteBridgeRequest } from '../../types';
+import { SupportedChainId, TargetChainId } from '../../../chains';
+import { AcrossDepositEvent, CowTradeEvent, DepositStatusResponse, SuggestedFeesResponse } from './types';
 import { AcrossQuoteResult } from './AcrossBridgeProvider';
 import { AcrossChainConfig } from './const/tokens';
-import { SuggestedFeesResponse } from './types';
 /**
  * Return the chain configs
  *
@@ -37,3 +38,6 @@ export declare function pctToBps(pct: bigint): number;
  */
 export declare function applyPctFee(amount: bigint, pct: bigint): bigint;
 export declare function applyBps(amount: bigint, bps: number): bigint;
+export declare function mapAcrossStatusToBridgeStatus(status: DepositStatusResponse['status']): BridgeStatus;
+export declare function getAcrossDepositEvents(chainId: SupportedChainId, logs: Log[]): AcrossDepositEvent[];
+export declare function getCowTradeEvents(chainId: SupportedChainId, logs: Log[]): CowTradeEvent[];

package/dist/bridging/providers/bungee/BungeeApi.d.ts

@@ -0,0 +1,52 @@
+import { AcrossStatus, BungeeBuildTx, BungeeEvent, BungeeQuote, BungeeQuoteAPIRequest, BungeeQuoteWithBuildTx, SocketRequest, SupportedBridge } from './types';
+import { SignerLike } from '../../../common';
+import { SupportedChainId } from '../../../chains';
+export interface BungeeApiOptions {
+    apiBaseUrl?: string;
+    eventsApiBaseUrl?: string;
+    acrossApiBaseUrl?: string;
+    includeBridges?: SupportedBridge[];
+}
+export declare class BungeeApi {
+    private readonly options;
+    readonly SUPPORTED_BRIDGES: SupportedBridge[];
+    constructor(options?: BungeeApiOptions);
+    validateBridges(includeBridges: SupportedBridge[]): void;
+    /**
+     * Makes a GET request to Bungee APIs for quote and build tx
+     */
+    getBungeeQuoteWithBuildTx(params: BungeeQuoteAPIRequest): Promise<BungeeQuoteWithBuildTx>;
+    /**
+     * Makes a GET request to Bungee APIs for quote
+     * https://docs.bungee.exchange/bungee-api/api-reference/bungee-controller-quote-v-1
+     */
+    getBungeeQuote(params: BungeeQuoteAPIRequest): Promise<BungeeQuote>;
+    /**
+     * Makes a GET request to Bungee APIs for build tx
+     * https://docs.bungee.exchange/bungee-api/api-reference/bungee-controller-build-tx-v-1
+     */
+    getBungeeBuildTx(quote: BungeeQuote): Promise<BungeeBuildTx>;
+    /**
+     * Verifies the build tx data for a quote using the SocketVerifier contract
+     * @param quote - The quote object
+     * @param buildTx - The build tx object
+     * @param signer - The signer object
+     * @returns True if the build tx data is valid, false otherwise
+     */
+    verifyBungeeBuildTx(quote: BungeeQuote, buildTx: BungeeBuildTx, signer: SignerLike): Promise<boolean>;
+    /**
+     * Verifies the bungee tx data using the SocketVerifier contract
+     * @param originChainId - The origin chain id
+     * @param txData - The tx data
+     * @param routeId - The route id
+     * @param expectedSocketRequest - The expected socket request
+     * @param signer - The signer object
+     * @returns True if the bungee tx data is valid, false otherwise
+     */
+    verifyBungeeBuildTxData(originChainId: SupportedChainId, txData: string, routeId: string, expectedSocketRequest: SocketRequest, signer: SignerLike): Promise<boolean>;
+    getEvents(params: {
+        orderId: string;
+    }): Promise<BungeeEvent[]>;
+    getAcrossStatus(depositTxHash: string): Promise<AcrossStatus>;
+    private makeApiCall;
+}

package/dist/bridging/providers/bungee/BungeeBridgeProvider.d.ts

@@ -0,0 +1,40 @@
+import { Signer } from 'ethers';
+import { latest as latestAppData } from '@cowprotocol/app-data';
+import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, BridgingDepositParams, QuoteBridgeRequest } from '../../types';
+import { ChainId, ChainInfo, SupportedChainId, TargetChainId } from '../../../chains';
+import { EvmCall, TokenInfo } from '../../../common';
+import { BungeeApi, BungeeApiOptions } from './BungeeApi';
+import { CowShedSdk, CowShedSdkOptions } from '../../../cow-shed';
+import { BungeeBuildTx, BungeeQuote } from './types';
+import { JsonRpcProvider } from '@ethersproject/providers';
+export declare const BUNGEE_HOOK_DAPP_ID = "cow-sdk://bridging/providers/bungee";
+export declare const BUNGEE_SUPPORTED_NETWORKS: ChainInfo[];
+export interface BungeeBridgeProviderOptions {
+    apiOptions?: BungeeApiOptions;
+    cowShedOptions?: CowShedSdkOptions;
+}
+export interface BungeeQuoteResult extends BridgeQuoteResult {
+    bungeeQuote: BungeeQuote;
+    buildTx: BungeeBuildTx;
+}
+export declare class BungeeBridgeProvider implements BridgeProvider<BungeeQuoteResult> {
+    private options;
+    protected api: BungeeApi;
+    protected cowShedSdk: CowShedSdk;
+    constructor(options?: BungeeBridgeProviderOptions);
+    info: BridgeProviderInfo;
+    getNetworks(): Promise<ChainInfo[]>;
+    getBuyTokens(targetChainId: TargetChainId): Promise<TokenInfo[]>;
+    getIntermediateTokens(request: QuoteBridgeRequest): Promise<TokenInfo[]>;
+    getQuote(request: QuoteBridgeRequest): Promise<BungeeQuoteResult>;
+    getUnsignedBridgeCall(request: QuoteBridgeRequest, quote: BungeeQuoteResult): Promise<EvmCall>;
+    getGasLimitEstimationForHook(_request: QuoteBridgeRequest): number;
+    getSignedHook(chainId: SupportedChainId, unsignedCall: EvmCall, signer: Signer, defaultGasLimit?: bigint): Promise<BridgeHook>;
+    getBridgingParams(_chainId: ChainId, _provider: JsonRpcProvider, _orderUid: string, _txHash: string): Promise<BridgingDepositParams | null>;
+    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/bungee/abi.d.ts

@@ -0,0 +1,192 @@
+export declare const ERC20_ABI: string[];
+export declare const SOCKET_VERIFIER_ABI: ({
+    type: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+    name?: undefined;
+    outputs?: undefined;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+        components: {
+            name: string;
+            type: string;
+            internalType: string;
+        }[];
+    }[];
+    stateMutability: string;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: ({
+        name: string;
+        type: string;
+        internalType: string;
+        components?: undefined;
+    } | {
+        name: string;
+        type: string;
+        internalType: string;
+        components: ({
+            name: string;
+            type: string;
+            internalType: string;
+            components?: undefined;
+        } | {
+            name: string;
+            type: string;
+            internalType: string;
+            components: {
+                name: string;
+                type: string;
+                internalType: string;
+            }[];
+        })[];
+    })[];
+    outputs: never[];
+    stateMutability: string;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        indexed: boolean;
+        internalType: string;
+    }[];
+    anonymous: boolean;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: never[];
+    stateMutability?: undefined;
+    outputs?: undefined;
+    anonymous?: undefined;
+})[];
+export declare const BUNGEE_COWSWAP_LIB_ABI: ({
+    inputs: never[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+})[];
+export declare const SOCKET_GATEWAY_ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    stateMutability: string;
+    type: string;
+    inputs?: undefined;
+    name?: undefined;
+    anonymous?: 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: {
+            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;
+})[];

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

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

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

@@ -0,0 +1,3 @@
+import { BungeeTxDataBytesIndicesType } from '../types';
+export declare const HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";
+export declare const BungeeTxDataBytesIndices: BungeeTxDataBytesIndicesType;

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

@@ -0,0 +1,7 @@
+import { ChainId } from '../../../../chains/types';
+import { TokenInfo } from '../../../../common';
+/**
+ * Chain config for Bungee. Includes all the supported tokens for the chain.
+ */
+export type BungeeChainConfig = Record<ChainId, Record<string, TokenInfo | undefined>>;
+export declare const BUNGEE_CHAIN_TOKENS: BungeeChainConfig;

package/dist/bridging/providers/bungee/createBungeeDepositCall.d.ts

@@ -0,0 +1,9 @@
+import { EvmCall } from '../../../common';
+import { CowShedSdk } from '../../../cow-shed';
+import { BungeeQuoteResult } from './BungeeBridgeProvider';
+import { QuoteBridgeRequest } from '../../types';
+export declare function createBungeeDepositCall(params: {
+    request: QuoteBridgeRequest;
+    quote: BungeeQuoteResult;
+    cowShedSdk: CowShedSdk;
+}): Promise<EvmCall>;