@cowprotocol/cow-sdk 6.0.0-RC.9 → 6.0.0

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

@@ -0,0 +1,267 @@
+export type SupportedBridge = 'across' | 'cctp';
+export interface BungeeQuoteAPIRequest {
+    userAddress: string;
+    originChainId: string;
+    destinationChainId: string;
+    inputToken: string;
+    inputAmount: string;
+    receiverAddress: string;
+    outputToken: string;
+    enableManual: true;
+    disableSwapping: true;
+    disableAuto: true;
+    includeBridges?: SupportedBridge[];
+}
+export interface BungeeQuoteAPIResponse {
+    success: boolean;
+    statusCode: number;
+    result: {
+        originChainId: number;
+        destinationChainId: number;
+        userAddress: string;
+        receiverAddress: string;
+        input: {
+            token: {
+                chainId: number;
+                address: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                logoURI: string;
+                icon: string;
+            };
+            amount: string;
+            priceInUsd: number;
+            valueInUsd: number;
+        };
+        destinationExec: unknown;
+        autoRoute: unknown;
+        manualRoutes: Array<{
+            quoteId: string;
+            quoteExpiry: number;
+            output: {
+                token: {
+                    chainId: number;
+                    address: string;
+                    name: string;
+                    symbol: string;
+                    decimals: number;
+                    logoURI: string;
+                    icon: string;
+                };
+                amount: string;
+                priceInUsd: number;
+                valueInUsd: number;
+                minAmountOut: string;
+                effectiveReceivedInUsd: number;
+            };
+            affiliateFee: unknown;
+            approvalData: {
+                spenderAddress: string;
+                amount: string;
+                tokenAddress: string;
+                userAddress: string;
+            };
+            gasFee: {
+                gasToken: {
+                    chainId: number;
+                    address: string;
+                    symbol: string;
+                    name: string;
+                    decimals: number;
+                    icon: string;
+                    logoURI: string;
+                    chainAgnosticId: unknown;
+                };
+                gasLimit: string;
+                gasPrice: string;
+                estimatedFee: string;
+                feeInUsd: number;
+            };
+            slippage: number;
+            estimatedTime: number;
+            routeDetails: {
+                name: string;
+                logoURI: string;
+                routeFee: {
+                    token: {
+                        chainId: number;
+                        address: string;
+                        name: string;
+                        symbol: string;
+                        decimals: number;
+                        logoURI: string;
+                        icon: string;
+                    };
+                    amount: string;
+                    feeInUsd: number;
+                    priceInUsd: number;
+                };
+                dexDetails: unknown;
+            };
+            refuel: unknown;
+        }>;
+    };
+}
+export declare enum BungeeBridge {
+    'Across' = "across",
+    'CircleCCTP' = "cctp"
+}
+export declare const BungeeBridgeNames: Record<string, BungeeBridge>;
+export interface BungeeQuote {
+    originChainId: number;
+    destinationChainId: number;
+    userAddress: string;
+    receiverAddress: string;
+    input: BungeeQuoteAPIResponse['result']['input'];
+    route: BungeeQuoteAPIResponse['result']['manualRoutes'][0];
+    routeBridge: BungeeBridge;
+    quoteTimestamp: number;
+}
+export type BungeeQuoteWithBuildTx = {
+    bungeeQuote: BungeeQuote;
+    buildTx: BungeeBuildTx;
+};
+export interface BungeeBuildTxAPIResponse {
+    success: boolean;
+    statusCode: number;
+    result: {
+        approvalData: {
+            spenderAddress: string;
+            amount: string;
+            tokenAddress: string;
+            userAddress: string;
+        };
+        txData: {
+            data: string;
+            to: string;
+            chainId: number;
+            value: string;
+        };
+        userOp: string;
+    };
+}
+export type BungeeBuildTx = BungeeBuildTxAPIResponse['result'];
+export interface InputAmountTxDataBytesIndices {
+    inputAmount: {
+        bytes_startIndex: number;
+        bytes_length: number;
+        bytesString_startIndex: number;
+        bytesString_length: number;
+    };
+}
+export interface OutputAmountTxDataBytesIndices {
+    outputAmount: {
+        bytes_startIndex: number;
+        bytes_length: number;
+        bytesString_startIndex: number;
+        bytesString_length: number;
+    };
+}
+export interface InputOutputAmountTxDataBytesIndices extends InputAmountTxDataBytesIndices, OutputAmountTxDataBytesIndices {
+}
+export type BungeeTxDataBytesIndicesType = {
+    [K in BungeeBridge]: {
+        [functionSelector: string]: K extends BungeeBridge.Across ? InputOutputAmountTxDataBytesIndices : InputAmountTxDataBytesIndices;
+    };
+};
+export type SocketRequest = {
+    amount: string;
+    recipient: string;
+    toChainId: string;
+    token: string;
+    signature: string;
+};
+export type UserRequestValidation = {
+    routeId: string;
+    socketRequest: SocketRequest;
+};
+export declare enum BungeeEventStatus {
+    COMPLETED = "COMPLETED",
+    PENDING = "PENDING"
+}
+export declare enum BungeeBridgeName {
+    ACROSS = "across",
+    CCTP = "cctp"
+}
+export type BungeeEvent = {
+    identifier: string;
+    srcTransactionHash?: string;
+    bridgeName: BungeeBridgeName;
+    fromChainId: number;
+    gasUsed: string;
+    isCowswapTrade: boolean;
+    isSocketTx: boolean;
+    metadata: string;
+    orderId: string;
+    recipient: string;
+    sender: string;
+    socketContractVersion: string;
+    srcAmount: string;
+    srcBlockHash: string;
+    srcBlockNumber: number;
+    srcBlockTimeStamp: number;
+    srcTokenAddress: string;
+    srcTokenDecimals: number;
+    srcTokenLogoURI: string;
+    srcTokenName: string;
+    srcTokenSymbol: string;
+    to: string;
+    toChainId: number;
+    destTransactionHash?: string;
+    destAmount?: string;
+    destBlockHash: string;
+    destBlockNumber: number;
+    destBlockTimeStamp: number;
+    destTokenAddress: string;
+    destTokenDecimals: number;
+    destTokenLogoURI: string;
+    destTokenName: string;
+    destTokenSymbol: string;
+    srcTxStatus: BungeeEventStatus;
+    destTxStatus: BungeeEventStatus;
+};
+export type BungeeEventsAPIResponse = {
+    success: boolean;
+    result: Array<BungeeEvent>;
+};
+export interface AcrossStatusAPIResponse {
+    status: 'filled' | 'pending' | 'expired' | 'refunded' | 'slowFillRequested';
+    originChainId: string;
+    depositId: string;
+    depositTxHash?: string;
+    fillTx?: string;
+    destinationChainId?: string;
+    depositRefundTxHash?: string;
+    pagination?: {
+        currentIndex: number;
+        maxIndex: number;
+    };
+}
+export type AcrossStatus = AcrossStatusAPIResponse['status'];
+export type BungeeBuyTokensAPIResponse = {
+    success: boolean;
+    statusCode: number;
+    result: Array<{
+        chainId: number;
+        address: string;
+        decimals: number;
+        name?: string;
+        symbol?: string;
+        logoURI?: string;
+        icon?: string;
+    }>;
+};
+export type BungeeIntermediateTokensAPIResponse = {
+    success: boolean;
+    statusCode: number;
+    result: Array<{
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        logoURI: string;
+        icon: string;
+    }>;
+};

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

@@ -0,0 +1,62 @@
+import { BungeeQuoteResult } from './BungeeBridgeProvider';
+import { BungeeQuoteWithBuildTx } from './types';
+import { ethers, Signer } from 'ethers';
+import { BungeeBridge } from './types';
+import { QuoteBridgeRequest } from '../../types';
+import { SignerLike } from '../../../common';
+/**
+ * Convert a QuoteBridgeRequest to a BungeeQuoteResult
+ * @param request - The QuoteBridgeRequest to convert
+ * @param slippageBps
+ * @param bungeeQuoteWithBuildTx
+ * @returns The BungeeQuoteResult
+ */
+export declare function toBridgeQuoteResult(request: QuoteBridgeRequest, slippageBps: number, bungeeQuoteWithBuildTx: BungeeQuoteWithBuildTx): BungeeQuoteResult;
+/**
+ * Decodes the txData from Bungee API
+ * @param txData - The txData to decode
+ * @returns The routeId and encoded function data
+ */
+export declare function decodeBungeeBridgeTxData(txData: string): {
+    routeId: string;
+    encodedFunctionData: string;
+    functionSelector: string;
+};
+export declare function applyBps(amount: bigint, bps: number): bigint;
+export declare function calculateFeeBps(feeAmountBig: bigint, amountBig: bigint): number;
+/**
+ * Converts an object to URLSearchParams, handling arrays by joining values with commas
+ * @param params Object to convert to URLSearchParams
+ * @returns URLSearchParams instance
+ *
+ * @example
+ * const params = {
+ *   userAddress: '0x123',
+ *   includeBridges: ['across', 'cctp']
+ * }
+ * const searchParams = objectToSearchParams(params)
+ * Results in: ?userAddress=0x123&includeBridges=across,cctp
+ */
+export declare function objectToSearchParams(params: object): URLSearchParams;
+export declare function getSignerForChainId(chainId: number, signer: SignerLike): Promise<Signer>;
+export declare function fetchTokenAllowance(params: {
+    chainId: number;
+    tokenAddress: string;
+    ownerAddress: string;
+    spenderAddress: string;
+    signer: SignerLike;
+}): Promise<bigint>;
+export declare function getErc20Contract(tokenAddress: string, signer?: ethers.Signer | ethers.providers.Provider): ethers.Contract;
+export declare const getBungeeBridgeFromDisplayName: (displayName: string) => BungeeBridge | undefined;
+export declare const getDisplayNameFromBungeeBridge: (bridge: BungeeBridge) => string | undefined;
+export declare const decodeAmountsBungeeTxData: (txData: string, bridge: BungeeBridge) => {
+    inputAmountBytes: string;
+    inputAmountBigNumber: ethers.BigNumber;
+    outputAmountBytes: string;
+    outputAmountBigNumber: ethers.BigNumber;
+} | {
+    inputAmountBytes: string;
+    inputAmountBigNumber: ethers.BigNumber;
+    outputAmountBytes?: undefined;
+    outputAmountBigNumber?: undefined;
+};

package/dist/bridging/providers/mock/MockBridgeProvider.d.ts

@@ -1,20 +1,26 @@
-import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, GetBuyTokensParams, QuoteBridgeRequest } from '../../types';
-import { EvmCall, TokenInfo } from '../../../common';
-import { ChainInfo, SupportedChainId } from '../../../chains';
-import { Signer } from '@ethersproject/abstract-signer';
-export declare class MockBridgeProvider implements BridgeProvider<BridgeQuoteResult> {
-    info: BridgeProviderInfo;
-    getNetworks(): Promise<ChainInfo[]>;
-    getBuyTokens(param: GetBuyTokensParams): Promise<TokenInfo[]>;
-    getIntermediateTokens(_request: QuoteBridgeRequest): Promise<string[]>;
-    getQuote(_request: QuoteBridgeRequest): Promise<BridgeQuoteResult>;
-    getGasLimitEstimationForHook(_request: QuoteBridgeRequest): number;
-    getUnsignedBridgeCall(_request: QuoteBridgeRequest, _quote: BridgeQuoteResult): Promise<EvmCall>;
-    getSignedHook(_chainId: SupportedChainId, _unsignedCall: EvmCall, _signer: Signer): Promise<BridgeHook>;
-    decodeBridgeHook(_hook: BridgeHook): Promise<BridgeDeposit>;
-    getBridgingId(_orderUid: string, _settlementTx: string): Promise<string>;
-    getExplorerUrl(bridgingId: string): string;
-    getStatus(_bridgingId: string): Promise<BridgeStatusResult>;
-    getCancelBridgingTx(_bridgingId: string): Promise<EvmCall>;
-    getRefundBridgingTx(_bridgingId: string): Promise<EvmCall>;
-}
+import { latest as latestAppData } from '@cowprotocol/app-data';
+import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, BridgingDepositParams, BuyTokensParams, QuoteBridgeRequest } from '../../types';
+import { Signer } from '@ethersproject/abstract-signer';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ChainId, ChainInfo, SupportedChainId } from '../../../chains';
+import { EvmCall, TokenInfo } from '../../../common';
+export declare class MockBridgeProvider implements BridgeProvider<BridgeQuoteResult> {
+    info: BridgeProviderInfo;
+    getRpcProvider(): JsonRpcProvider;
+    getNetworks(): Promise<ChainInfo[]>;
+    getBuyTokens(params: BuyTokensParams): Promise<TokenInfo[]>;
+    getIntermediateTokens({ sellTokenChainId }: QuoteBridgeRequest): Promise<TokenInfo[]>;
+    getQuote(_request: QuoteBridgeRequest): Promise<BridgeQuoteResult>;
+    getGasLimitEstimationForHook(_request: QuoteBridgeRequest): Promise<number>;
+    getUnsignedBridgeCall(_request: QuoteBridgeRequest, _quote: BridgeQuoteResult): Promise<EvmCall>;
+    getSignedHook(_chainId: SupportedChainId, _unsignedCall: EvmCall, _signer: Signer): Promise<BridgeHook>;
+    decodeBridgeHook(_hook: latestAppData.CoWHook): Promise<BridgeDeposit>;
+    getBridgingParams(_chainId: ChainId, _orderUid: string, _txHash: string): Promise<{
+        params: BridgingDepositParams;
+        status: BridgeStatusResult;
+    }>;
+    getExplorerUrl(bridgingId: string): string;
+    getStatus(_bridgingId: string): Promise<BridgeStatusResult>;
+    getCancelBridgingTx(_bridgingId: string): Promise<EvmCall>;
+    getRefundBridgingTx(_bridgingId: string): Promise<EvmCall>;
+}

package/dist/bridging/providers/utils/getGasLimitEstimationForHook.d.ts

@@ -0,0 +1,4 @@
+import { QuoteBridgeRequest } from '../../types';
+import type { JsonRpcProvider } from '@ethersproject/providers';
+import { CowShedSdk } from '../../../cow-shed';
+export declare function getGasLimitEstimationForHook(cowShedSdk: CowShedSdk, request: QuoteBridgeRequest, provider: JsonRpcProvider): Promise<number>;