@cowprotocol/cow-sdk 6.0.0-RC.31 → 6.0.0-RC.33

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

@@ -1,7 +1,8 @@
 import { SwapAdvancedSettings, TradingSdk } from '../../trading';
-import { BridgeProvider, BridgeQuoteResult, CrossChainQuoteAndPost, GetErc20Decimals, QuoteBridgeRequest } from '../types';
-import { TokenInfo } from '../../common';
-import { ChainInfo, TargetChainId } from '../../chains';
+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.
@@ -15,11 +16,32 @@ export interface BridgingSdkOptions {
      * 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.
@@ -64,4 +86,5 @@ export declare class BridgingSdk {
      * @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/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

@@ -1,4 +1,5 @@
 export * from './types';
+export * from './errors';
 export * from './utils';
 export * from './BridgingSdk/BridgingSdk';
 export { MockBridgeProvider } from './providers/mock/MockBridgeProvider';

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

@@ -1,172 +1,4 @@
-import { 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;
-}
+import { AvailableRoutesRequest, Route, SuggestedFeesRequest, SuggestedFeesResponse } from './types';
 export interface AcrossApiOptions {
     apiBaseUrl?: string;
 }

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

@@ -1,9 +1,11 @@
 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, SuggestedFeesResponse } from './AcrossApi';
+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 {
     /**
@@ -32,8 +34,8 @@ export declare class AcrossBridgeProvider implements BridgeProvider<AcrossQuoteR
     getUnsignedBridgeCall(request: QuoteBridgeRequest, quote: AcrossQuoteResult): Promise<EvmCall>;
     getGasLimitEstimationForHook(_request: QuoteBridgeRequest): number;
     getSignedHook(chainId: SupportedChainId, unsignedCall: EvmCall, signer: Signer): Promise<BridgeHook>;
-    decodeBridgeHook(_hook: BridgeHook): Promise<BridgeDeposit>;
-    getBridgingId(_orderUid: string, _settlementTx: string): Promise<string>;
+    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>;

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/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

@@ -1,8 +1,8 @@
 import { QuoteBridgeRequest } from '../../../bridging/types';
 import { TargetChainId } from '../../../chains';
-import { SuggestedFeesResponse } from './AcrossApi';
 import { AcrossQuoteResult } from './AcrossBridgeProvider';
 import { AcrossChainConfig } from './const/tokens';
+import { SuggestedFeesResponse } from './types';
 /**
  * Return the chain configs
  *

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

@@ -1,3 +1,4 @@
+import { latest as latestAppData } from '@cowprotocol/app-data';
 import { BridgeDeposit, BridgeHook, BridgeProvider, BridgeProviderInfo, BridgeQuoteResult, BridgeStatusResult, QuoteBridgeRequest } from '../../types';
 import { EvmCall, TokenInfo } from '../../../common';
 import { ChainInfo, SupportedChainId, TargetChainId } from '../../../chains';
@@ -11,8 +12,8 @@ export declare class MockBridgeProvider implements BridgeProvider<BridgeQuoteRes
     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>;
+    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>;

package/dist/bridging/types.d.ts

@@ -1,7 +1,7 @@
 import { latest as latestAppData } from '@cowprotocol/app-data';
 import { ChainInfo, SupportedChainId, TargetChainId } from '../chains';
 import { TokenInfo } from '../common/types/tokens';
-import { Address, Amounts, OrderKind } from '../order-book';
+import { Address, Amounts, EnrichedOrder, OrderKind } from '../order-book';
 import { EvmCall } from '../common/types/ethereum';
 import type { AccountAddress } from '../common/types/wallets';
 import { OrderPostingResult, QuoteAndPost, QuoteResults, QuoterParameters, TradeOptionalParameters, TraderParameters } from '../trading';
@@ -48,6 +48,30 @@ export interface BridgeQuoteResult {
      * The timestamp of the quote.
      */
     quoteTimestamp: number;
+    fees: {
+        /**
+         * The amount that should go to the relayer as a fee to cover relayer capital costs.
+         * In token atoms.
+         */
+        bridgeFee: bigint;
+        /**
+         * The amount that should go to the relayer as a fee to cover relayer gas costs.
+         * In token atoms.
+         */
+        destinationGasFee: bigint;
+    };
+    limits: {
+        /**
+         * The minimum amount that should be deposited in the source chain.
+         * In token atoms.
+         */
+        minDeposit: bigint;
+        /**
+         * The maximum amount that can be deposited in the source chain.
+         * In token atoms.
+         */
+        maxDeposit: bigint;
+    };
 }
 export interface BridgeHook {
     postHook: latestAppData.CoWHook;
@@ -145,13 +169,14 @@ export interface BridgeProvider<Q extends BridgeQuoteResult> {
      *
      * @param hook - The bridge hook
      */
-    decodeBridgeHook(hook: BridgeHook): Promise<BridgeDeposit>;
+    decodeBridgeHook(hook: latestAppData.CoWHook): Promise<BridgeDeposit>;
     /**
      * Get the identifier of the bridging transaction from the settlement transaction.
      * @param orderUid - The unique identifier of the order
      * @param settlementTx - The settlement transaction in which the bridging post-hook was executed
+     * @param logIndex - The log index of the trade within the settlement transaction
      */
-    getBridgingId(orderUid: string, settlementTx: string): Promise<string>;
+    getBridgingId(orderUid: string, settlementTx: string, logIndex: number): Promise<string>;
     /**
      * Get the explorer url for a bridging id.
      *
@@ -251,4 +276,12 @@ export interface BridgeQuoteResults extends BridgeQuoteResult {
     bridgeCallDetails: BridgeCallDetails;
 }
 export type GetErc20Decimals = (chainId: TargetChainId, tokenAddress: string) => Promise<number>;
+export interface CrossChainOrder {
+    chainId: SupportedChainId;
+    order: EnrichedOrder;
+    status: BridgeStatus;
+    bridgingId?: string;
+    explorerUrl?: string;
+    fillTimeInSeconds?: number;
+}
 export {};

package/dist/bridging/utils.d.ts

@@ -1,6 +1,9 @@
 import { QuoteAndPost } from '../trading';
+import { latest as latestAppData } from '@cowprotocol/app-data';
 import { BridgeQuoteAndPost, CrossChainQuoteAndPost } from './types';
 export declare function isBridgeQuoteAndPost(quote: CrossChainQuoteAndPost): quote is BridgeQuoteAndPost;
 export declare function isQuoteAndPost(quote: CrossChainQuoteAndPost): quote is QuoteAndPost;
 export declare function assertIsBridgeQuoteAndPost(quote: CrossChainQuoteAndPost): asserts quote is BridgeQuoteAndPost;
 export declare function assertIsQuoteAndPost(quote: CrossChainQuoteAndPost): asserts quote is QuoteAndPost;
+export declare function getPostHooks(fullAppData?: string): latestAppData.CoWHook[];
+export declare function isAppDoc(appData: unknown): appData is latestAppData.AppDataRootSchema;