@0xsquid/react-hooks 9.0.0-beta-bump-wagmi-viem.1 → 9.0.0-beta-nodev24.0

package/dist/services/internal/cantonDamlValue.d.ts

@@ -0,0 +1,71 @@
+export type DamlValueJson = {
+    party: string;
+} | {
+    text: string;
+} | {
+    numeric: string;
+} | {
+    contractId: string;
+} | {
+    timestamp: string;
+} | {
+    bool: boolean;
+} | {
+    list: {
+        elements: DamlValueJson[];
+    };
+} | {
+    record: {
+        fields: Array<{
+            label: string;
+            value: DamlValueJson;
+        }>;
+    };
+} | {
+    textMap: {
+        entries: Array<{
+            key: string;
+            value: DamlValueJson;
+        }>;
+    };
+} | {
+    variant: {
+        constructor: string;
+        value: DamlValueJson;
+    };
+};
+type DamlValueField = [label: string, value: DamlValueJson];
+type ChoiceContextScalar = string | number | boolean | null;
+type ChoiceContextObject = {
+    [key: string]: ChoiceContextScalar;
+};
+type TaggedChoiceContextValue = string | {
+    tag: "AV_Text";
+    value: string;
+} | {
+    tag: "AV_ContractId";
+    value: string;
+} | {
+    tag: "AV_Bool";
+    value: boolean;
+} | {
+    tag: "AV_List";
+    value: TaggedChoiceContextValue[];
+} | {
+    tag: string;
+    value: ChoiceContextScalar | TaggedChoiceContextValue[] | ChoiceContextObject;
+};
+export declare const vParty: (party: string) => DamlValueJson;
+export declare const vText: (text: string) => DamlValueJson;
+export declare const vNumeric: (numeric: string) => DamlValueJson;
+export declare const vContractId: (contractId: string) => DamlValueJson;
+export declare const vList: (elements: DamlValueJson[]) => DamlValueJson;
+export declare const vRecord: (fields: DamlValueField[]) => DamlValueJson;
+export declare const vTextMap: (entries: Array<{
+    key: string;
+    value: DamlValueJson;
+}>) => DamlValueJson;
+export declare const vTimestamp: (isoString: string) => DamlValueJson;
+export declare function normalizeChoiceContextValue(value: unknown): TaggedChoiceContextValue | null;
+export declare function choiceContextValueToAnyValue(value: TaggedChoiceContextValue): DamlValueJson;
+export {};

package/dist/services/internal/cantonService.d.ts

@@ -0,0 +1,82 @@
+import { CantonConnector, CantonHolding, CantonInstrument } from "../../core/types/canton";
+import { CantonWallet, ConnectorID } from "../../core/types/wallet";
+export declare function getCantonCommandId(memo: string): string;
+/**
+ * Format a Canton connector into a Squid {@link CantonWallet}. Shared by the
+ * announce-discovery and injected-provider paths.
+ */
+export declare function formatCantonWallet({ connectorId, name, icon, connector, }: {
+    connectorId: ConnectorID;
+    name: string;
+    icon: string | undefined;
+    connector: CantonConnector;
+}): CantonWallet;
+/**
+ * Append injected wallets that aren't already covered by an announce-discovered
+ * wallet with the same connectorId (in case a wallet later does both).
+ */
+export declare function mergeInjectedCantonWallets(announced: CantonWallet[], injected: CantonWallet[]): CantonWallet[];
+export declare const CANTON_PARTY_ID_SEPARATOR = "::";
+/** Canton Coin's well-known token-standard instrument id (its address carries no id prefix). */
+export declare const CANTON_AMULET_INSTRUMENT_ID = "Amulet";
+export declare function isCantonAddressValid(address: string): boolean;
+/**
+ * Splice token-standard Holding interface id. A party's balance for an
+ * instrument is the sum of `amount` across active contracts implementing this interface.
+ */
+export declare const CANTON_HOLDING_INTERFACE_ID = "#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding";
+/**
+ * Derive the token-standard instrument `{ admin, id }` from a Squid Canton token
+ * address (use the case-sensitive `originalAddress`), or `null` when the address
+ * is not a valid Canton token address.
+ *
+ * The admin party is the last two `::` segments (`name::fingerprint`); the
+ * instrument id is everything before that. Canton Coin has no id prefix
+ * (`DSO::1220…`) and uses the well-known id `Amulet`.
+ *   - `DSO::1220…`                                  -> { admin: "DSO::1220…", id: "Amulet" }
+ *   - `USDCx::decentralized-usdc-…::12208…`         -> { admin: "decentralized-usdc-…::12208…", id: "USDCx" }
+ */
+export declare function parseCantonInstrument(address: string): CantonInstrument | null;
+/**
+ * Body for `POST /v2/state/active-contracts`, filtered to the party's Holding
+ * contracts with the interface view included (so we can read amount/instrument).
+ *
+ * ACS: Active Contract Set — the ledger's currently-active contracts (created and
+ * not yet archived) as of a ledger offset.
+ */
+export declare function buildHoldingsAcsRequestBody(partyId: string, activeAtOffset: string): {
+    activeAtOffset: string;
+    eventFormat: {
+        verbose: boolean;
+        filtersByParty: {
+            [x: string]: {
+                cumulative: {
+                    identifierFilter: {
+                        InterfaceFilter: {
+                            value: {
+                                interfaceId: string;
+                                includeInterfaceView: boolean;
+                                includeCreatedEventBlob: boolean;
+                            };
+                        };
+                    };
+                }[];
+            };
+        };
+    };
+};
+/**
+ * Parse the party's Holding contracts (with contract ids) from a raw
+ * `/v2/state/active-contracts` response
+ *  Defensive: skips entries it can't parse.
+ */
+export declare function parseCantonHoldings(acsResponse: unknown): CantonHolding[];
+export declare function cantonInstrumentKey(instrument: CantonInstrument): string;
+/**
+ * Group the (unlocked) Holding amounts by instrument from a raw
+ * `/v2/state/active-contracts` response. Returns a map of instrument key
+ * (`admin|id`) -> human-readable decimal string (the token-standard `amount`
+ * is already a Decimal, not base units).
+ */
+export declare function groupCantonHoldingBalances(acsResponse: unknown): Record<string, string>;
+export declare function sumCantonHoldingBalances(holdings: readonly Pick<CantonHolding, "instrument" | "amount">[]): Record<string, string>;

package/dist/services/internal/cantonTransferService.d.ts

@@ -0,0 +1,93 @@
+import type { CantonLedgerReader, CantonHolding, CantonInstrument, CantonPrepareExecuteParams } from "../../core/types/canton";
+import type { Token } from "../../core/types/tokens";
+import type { DamlValueJson } from "./cantonDamlValue";
+/** Metadata key used by Splice token-standard transfers to carry our Squid orderhash memo. */
+export declare const CANTON_MEMO_KEY = "splice.lfdecentralizedtrust.org/reason";
+/** Interface id for the transfer factory contract returned by the token registry. */
+export declare const TRANSFER_FACTORY_INTERFACE_ID = "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory";
+export declare function resolveCantonRegistryUrl(instrument: CantonInstrument): string;
+type ChoiceContextData = {
+    values?: Record<string, unknown>;
+} & Record<string, unknown>;
+interface TransferChoiceArgs {
+    expectedAdmin: string;
+    transfer: {
+        sender: string;
+        receiver: string;
+        amount: string;
+        instrumentId: {
+            admin: string;
+            id: string;
+        };
+        requestedAt: string;
+        executeBefore: string;
+        /**
+         * The input holdings to transfer.
+         * Cids: Contract IDs
+         */
+        inputHoldingCids: string[];
+        meta: {
+            values: Record<string, string>;
+        };
+    };
+    extraArgs: {
+        context: ChoiceContextData;
+        meta: {
+            values: Record<string, string>;
+        };
+    };
+}
+/**
+ * Build the plain JSON arguments expected by the registry transfer-factory
+ * endpoint before it adds choice context and disclosed contracts.
+ */
+export declare function buildTransferChoiceArgs({ sender, receiver, amount, instrument, inputHoldingCids, memo, nowMs, }: {
+    sender: string;
+    receiver: string;
+    amount: string;
+    instrument: CantonInstrument;
+    inputHoldingCids: string[];
+    memo: string;
+    nowMs: number;
+}): TransferChoiceArgs;
+/**
+ * Canton's Holding contracts follow Bitcoin-style UTXOs model.
+ *
+ * Pick Holding contract ids covering `amount` for the instrument: prefer a
+ * single exact-amount holding, else accumulate largest-first.
+ */
+export declare function selectInputHoldingCids(holdings: CantonHolding[], instrument: CantonInstrument, amount: string): string[];
+export declare function fetchInputHoldingCids(connector: CantonLedgerReader, party: string, instrument: CantonInstrument, amount: string): Promise<string[]>;
+interface TransferFactoryResponse {
+    factoryId: string;
+    transferKind?: string;
+    choiceContext: {
+        choiceContextData?: ChoiceContextData;
+        disclosedContracts?: Array<Record<string, unknown>>;
+    };
+}
+/**
+ * Ask the token registry for the transfer factory contract and extra context
+ * required to exercise its transfer choice.
+ */
+export declare function fetchTransferFactory(registryUrl: string, choiceArgs: TransferChoiceArgs): Promise<TransferFactoryResponse>;
+/**
+ * Convert transfer choice args into strict Daml Value JSON for the wallet's
+ * prepareExecute ExerciseCommand.
+ */
+export declare function buildPrepareChoiceArgument(choiceArgs: TransferChoiceArgs): DamlValueJson;
+/**
+ * Build a Splice token-standard transfer of `amount` of `token` from `sender`
+ * to `receiver`, carrying `memo`, ready to hand to a wallet's prepareExecute.
+ * Returns the full prepareExecute params (commandId + commands + actAs +
+ * disclosedContracts).
+ */
+export declare function buildCantonTransfer(connector: CantonLedgerReader, { sender, receiver, amount, token, memo, nowMs, }: {
+    sender: string;
+    receiver: string;
+    amount: string;
+    token: Token;
+    memo: string;
+    nowMs: number;
+}): Promise<CantonPrepareExecuteParams>;
+export {};

package/dist/services/internal/configService.d.ts

@@ -1,7 +1,8 @@
 import { QueryClient } from "@tanstack/react-query";
-import type { AppConfig } from "../../core/types/config";
+import type { AppConfig, NamedTokenConfig, TokenConfig } from "../../core/types/config";
 import { SwapDirection } from "../../core/types/swap";
 import { Chain, Token } from "../../core/types/tokens";
+export declare const resolveChainIdFromAsset: (asset: TokenConfig | NamedTokenConfig, chains: Chain[]) => string | undefined;
 export declare const getConfigWithDefaults: (config: AppConfig | undefined) => AppConfig;
 export declare const randomIntFromInterval: (min: number, max: number) => number;
 export declare const getTokensForChain: (tokens: Token[], chainId: number | string | undefined) => Token[];

package/dist/services/internal/errorService.d.ts

@@ -1,16 +1,19 @@
 import { RouteResponse } from "@0xsquid/squid-types";
-import type { SquidRouteError, SquidStatusError, TransactionErrorWithMessage } from "../../core/types/error";
+import type { SquidRouteError, TransactionErrorWithMessage } from "../../core/types/error";
 import type { TransactionParams } from "../../core/types/transaction";
 interface NormalizedError {
     code?: string | number;
     message?: string;
     reason?: string;
+    dataCode?: string | number;
+    dataMessage?: string;
+    causeMessage?: string;
 }
 /**
  * Normalizes different error structures into a consistent format
  * This helps handle different wallet error formats uniformly
  */
-export declare const normalizeError: (error: any) => NormalizedError;
+export declare const normalizeError: (error: unknown) => NormalizedError;
 export declare const transactionErrorCode: Record<string, TransactionErrorWithMessage>;
 /**
  * Detects if an error is a user rejection based on normalized error structure
@@ -21,7 +24,7 @@ export declare const isUserRejectionError: (normalizedError: NormalizedError) =>
  * @param error The error to convert
  * @returns A standardized error object
  */
-export declare const getTransactionError: (error: any) => TransactionErrorWithMessage;
+export declare const getTransactionError: (error: unknown) => TransactionErrorWithMessage;
 /**
  * Handles dispatching appropriate events based on the error type
  */
@@ -35,5 +38,4 @@ export declare const handleTransactionErrorEvents: ({ error, transactionParams,
  * Check if the error is a Squid route error
  */
 export declare const isSwapRouteError: (error: any) => error is SquidRouteError;
-export declare const isStatusError: (error: any) => error is SquidStatusError;
 export {};

package/dist/services/internal/estimateService.d.ts

@@ -1,6 +1,7 @@
 import { RouteResponse } from "@0xsquid/sdk/dist/types";
-import { ChainData, ChainType, FeeCost, GasCost, Token } from "@0xsquid/squid-types";
+import { ChainData, ChainType, Estimate, FeeCost, GasCost, Token } from "@0xsquid/squid-types";
 import { SimplifiedRouteAction } from "../../core/types/transaction";
+import { ChainFeeParams } from "./tempoService";
 export type PartialFeeCost = Pick<FeeCost, "amount"> & {
     token?: Pick<FeeCost["token"], "decimals">;
 };
@@ -19,18 +20,15 @@ export declare const calculateTotalNativeFees: ({ expressFeeCost, firstFeeCost,
     firstGasCost: Pick<GasCost, "amount"> | undefined;
     sameTokenBetweenFees: boolean;
 }) => bigint;
-export declare const isFromBalanceEnoughToSwap: ({ isFromTokenNative, fromAmount, totalFeesInNativeTokenPlusRatio, nativeTokenBalanceFromChainWei, }: {
-    isFromTokenNative: boolean;
+export declare const checkIsGasBalanceEnough: ({ fromAmount, networkFeesWei, chainFeeParams, }: {
     fromAmount: string | undefined;
-    fromTokenDecimals: number | undefined;
-    totalFeesInNativeTokenPlusRatio: bigint;
-    nativeTokenBalanceFromChainWei: bigint;
+    networkFeesWei: bigint;
+    chainFeeParams: ChainFeeParams | null;
 }) => boolean;
-export declare const calculateMinAmountValueWarnMsg: ({ isFromTokenNative, nativeTokenBalanceFromChainWei, sourceChainNativeTokenDecimals, totalFeesInNativeTokenPlusRatio, }: {
-    isFromTokenNative: boolean;
-    nativeTokenBalanceFromChainWei: bigint;
-    sourceChainNativeTokenDecimals: number | undefined;
-    totalFeesInNativeTokenPlusRatio: bigint;
+export declare const calculateMinAmountValueWarnMsg: ({ networkFeesWei, chainFeeParams, fromTokenDecimals, }: {
+    networkFeesWei: bigint;
+    chainFeeParams: ChainFeeParams | null;
+    fromTokenDecimals: number | undefined;
 }) => string | undefined;
 /**
  * Calculates the estimated duration of a route
@@ -60,19 +58,28 @@ export declare const formatEstimatedRouteDuration: ({ estimatedRouteDuration, is
  * @returns {Object} An object containing various estimate results and calculations, including token information,
  *                   amounts, fees, gas costs, and other relevant data for the transaction.
  */
-export declare const calculateEstimateResults: ({ squidRoute, tokens, fromChain, toChain, collectFees, nativeTokenBalanceFromChainWei, }: {
-    squidRoute: RouteResponse["route"] | undefined;
-    tokens: Token[];
-    fromChain?: ChainData | undefined;
-    toChain?: ChainData | undefined;
+export type EstimateRouteInput = {
+    params: Pick<RouteResponse["route"]["params"], "fromChain" | "fromToken">;
+    estimate: Pick<Estimate, "fromAmount" | "toAmount" | "toAmountMin" | "toAmountUSD" | "toAmountMinUSD" | "exchangeRate" | "estimatedRouteDuration" | "feeCosts"> & {
+        toToken: Pick<Token, "decimals">;
+        gasCosts: (Omit<GasCost, "token"> & {
+            token: Pick<Token, "chainId" | "address" | "decimals">;
+        })[];
+        actions?: Estimate["actions"];
+    };
+};
+export declare const calculateEstimateResults: <T extends Pick<Token, "chainId" | "address" | "decimals"> = Token>({ squidRoute, tokens, fromChain, toChain, collectFees, chainFeeParams, gasToken, }: {
+    squidRoute: EstimateRouteInput | undefined;
+    tokens: T[];
+    fromChain?: Pick<ChainData, "chainType" | "chainId"> | undefined;
+    toChain?: Pick<ChainData, "chainType" | "chainId"> | undefined;
     collectFees: boolean;
-    nativeTokenBalanceFromChainWei: bigint;
+    chainFeeParams: ChainFeeParams | null;
+    gasToken: Pick<Token, "decimals"> | undefined;
 }) => {
-    fromToken: any;
+    fromToken: T | undefined;
     fromAmount: string | undefined;
     fromAmountFormatted: string;
-    sourceChainNativeToken: Token | undefined;
-    destChainNativeToken: Token | undefined;
     toAmountUSD: string | undefined;
     exchangeRate: string;
     toAmountMinUSD: string;
@@ -87,15 +94,15 @@ export declare const calculateEstimateResults: ({ squidRoute, tokens, fromChain,
     expectedGasRefundCost: bigint;
     expectedGasRefundCostUSD: string;
     sameTokenBetweenFees: boolean;
-    isFromTokenNative: boolean;
+    fromTokenPaysGasFees: boolean;
     totalNativeFees: bigint;
-    totalFeesInNativeTokenPlusRatio: bigint;
-    fromBalanceEnoughToSwap: boolean;
+    isGasBalanceEnough: boolean;
     minAmountValueWarnMsg: string | undefined;
     estimatedRouteDuration: {
         seconds: number;
         format: (sTemplate?: string, mTemplate?: string, hTemplate?: string) => string;
     };
+    gasBalanceNeeded: string | undefined;
 };
 /**
  * Calculates the total estimate with refund for a transaction.
@@ -110,13 +117,3 @@ export declare const calculateTotalWithRefundEstimate: (allFeeCosts: FeeCost[] |
     totalAmountUSD: number;
     feeToken: Token | undefined;
 };
-/**
- * Calculates the proposed gas amount for the destination chain.
- *
- * @param destChainNativeToken - The symbol of the native token for the destination chain.
- * @returns An object containing the proposed gas amount value and the currency symbol.
- */
-export declare const getProposedGasDestinationAmount: (destChainNativeToken: string | undefined) => {
-    value: number;
-    currency: string | undefined;
-};

package/dist/services/internal/eventService.d.ts

@@ -56,6 +56,10 @@ export declare class WidgetEvents extends EventTarget {
         toChainId?: string;
         fromTokenAddress?: string;
         toTokenAddress?: string;
+        fromNetworkName?: string;
+        toNetworkName?: string;
+        fromTokenSymbol?: string;
+        toTokenSymbol?: string;
     }): void;
     /**
      * Dispatch event when we are waiting for the user to sign the swap transaction

package/dist/services/internal/evmService.d.ts

@@ -1,18 +1,20 @@
-import { ChainData } from "@0xsquid/squid-types";
+import { ChainData, Token } from "@0xsquid/squid-types";
 import type { TransactionReceipt, TransactionResponse } from "ethers";
 import { Address as EvmAddress } from "viem";
 import { Connector } from "wagmi";
 import { EvmWallet } from "../../core/types/wallet";
 export declare const EvmNetworkNotSupportedErrorCode = 4902;
+export declare function requiresZeroAllowanceReset(token: Token): boolean;
 export declare function addEthereumChain({ chain, provider, }: {
     chain: ChainData;
     provider: any;
 }): Promise<any>;
+export declare const isEvmAddressValid: (address: string | undefined) => boolean;
 export declare const parseEvmAddress: (address: string | undefined) => EvmAddress | undefined;
 /**
  * Formats a Wagmi connector into a Squid Wallet
  */
-export declare function formatEvmWallet(connector: Connector): EvmWallet;
+export declare function formatEvmWallet(connector: Connector, isMetaMaskAnnounced?: boolean): EvmWallet;
 export declare function filterWagmiConnector(connector: Connector): boolean;
 /**
  * Waits for a transaction receipt, handling retries if indexing is in progress

package/dist/services/internal/solanaTokenProgramService.d.ts

@@ -0,0 +1,9 @@
+import type { Token } from "@0xsquid/squid-types";
+import { Connection, PublicKey } from "@solana/web3.js";
+export declare const solanaTokenProgramIds: readonly [PublicKey, PublicKey];
+export declare const isSupportedSolanaTokenProgramId: (programId: PublicKey) => boolean;
+export declare const getSupportedSolanaTokenProgramId: (tokenProgramId?: string) => PublicKey | undefined;
+export declare const resolveSolanaTokenProgramId: ({ connection, token, }: {
+    connection: Connection;
+    token: Token;
+}) => Promise<PublicKey>;

package/dist/services/internal/status/statusApi.d.ts

@@ -0,0 +1,41 @@
+import type { StatusKeys, StatusWsTicket, SwapStatusResult } from "../../../core/types/status";
+export declare class SwapStatusRequestError extends Error {
+    /**
+     * Undefined when the request got no response
+     */
+    readonly httpStatus?: number | undefined;
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, 
+    /**
+     * Undefined when the request got no response
+     */
+    httpStatus?: number | undefined, retryAfterMs?: number | undefined, options?: ErrorOptions);
+}
+export interface SwapStatusRequestParams {
+    keys: StatusKeys;
+    apiUrl: string;
+    integratorId: string;
+    /**
+     * Without it, the backend does not register the deposit of a route with a
+     * `SquidDataType.OnChainExecutionWithSignature` or
+     * `SquidDataType.DepositAddressWithSignature` transaction request
+     */
+    depositTxVerificationSignature?: string;
+}
+/**
+ * Requests the status of a swap from `GET /v3/status`.
+ *
+ * A 404 is a normal answer until the backend tracks the transaction, so it is
+ * returned as a value. Every other failure throws a `SwapStatusRequestError`.
+ */
+export declare const fetchSwapStatus: (params: SwapStatusRequestParams) => Promise<SwapStatusResult>;
+interface StatusWsTicketRequestParams {
+    apiUrl: string;
+    integratorId: string;
+}
+/**
+ * Requests a ticket for one connection to the status WebSocket from
+ * `POST /v3/status/ws/token`
+ */
+export declare const requestStatusWsTicket: ({ apiUrl, integratorId, }: StatusWsTicketRequestParams) => Promise<StatusWsTicket>;
+export {};

package/dist/services/internal/status/statusExplorerLinks.d.ts

@@ -0,0 +1,52 @@
+import { type ChainData } from "@0xsquid/squid-types";
+import type { LegacyExplorerLinks } from "../../../core/types/history";
+import type { SwapStatusAction, SwapStatusBridgeSourceTxHashes, SwapStatusDocument } from "../../../core/types/status";
+import type { PatchedRouteActionResponse } from "../../../core/types/transaction";
+import { type SwapProgressRouteAction, type SwapRouteSegment } from "./statusSteps";
+export type SwapExplorerLinkType = "squidscan" | "axelarscan" | "chainflip" | "source";
+export interface SwapExplorerLinks {
+    source: string | undefined;
+    destination: string | undefined;
+    axelarscan: string | undefined;
+    squidscan: string | undefined;
+    chainflip: string | undefined;
+    /**
+     * The link that shows the most of the swap
+     */
+    main: {
+        type: SwapExplorerLinkType;
+        url: string;
+    } | undefined;
+}
+/**
+ * The fields that the links are built from. A `SwapStatusDocument` and the
+ * `statusSummary` of a history item both have them.
+ */
+export type SwapExplorerLinksSource = Pick<SwapStatusDocument, "transactionId" | "destinationTxHash" | "orderHash" | "bridges"> & {
+    actions?: Pick<SwapStatusAction, "type" | "bridgeType" | "sourceTxHash" | "swapId" | "depositChannelId" | "explorerUrl">[];
+    bridgeSourceTxHashes?: SwapStatusBridgeSourceTxHashes;
+    chainflipExplorerUrl?: string;
+};
+/**
+ * Builds the explorer links of a swap. The v3 status document has no URLs.
+ *
+ * @param statusTransactionId the transaction id that is sent to the status
+ * API. For a Chainflip deposit channel it is the channel id.
+ * @param sourceTxExplorerUrl the source link that the transaction already has.
+ * It is used instead of the link built from the source chain.
+ * @param legacy links that a history item got from the v2 status API
+ */
+export declare const getSwapExplorerLinks: ({ document, fromChain, toChain, statusTransactionId, sourceTxExplorerUrl, legacy, }: {
+    document: SwapExplorerLinksSource | undefined;
+    fromChain: ChainData | undefined;
+    toChain: ChainData | undefined;
+    statusTransactionId: string | undefined;
+    sourceTxExplorerUrl?: string | undefined;
+    legacy?: LegacyExplorerLinks | undefined;
+}) => SwapExplorerLinks;
+export declare const getSwapStepLink: ({ action, segment, links, fromChainId, }: {
+    action: SwapProgressRouteAction & Pick<PatchedRouteActionResponse, "provider">;
+    segment: SwapRouteSegment;
+    links: SwapExplorerLinks;
+    fromChainId: string | undefined;
+}) => string | undefined;

package/dist/services/internal/status/statusFollow.d.ts

@@ -0,0 +1,29 @@
+import { type SwapStatusOrNotFound } from "./statusMapping";
+export interface SwapStatusLimit {
+    /**
+     * Time of the transaction in milliseconds
+     */
+    startedAt?: number;
+    /**
+     * How long a 404 or a request error counts as "in progress", from
+     * `startedAt`. Without it, or with `Infinity`, the swap is followed until
+     * it has a final status.
+     */
+    notFoundTimeoutMs?: number;
+}
+export interface SwapFollowLimit extends SwapStatusLimit {
+    /**
+     * Time in milliseconds at which the swap started to fail
+     */
+    failedSince?: number;
+}
+export declare const getSwapStatusNotFoundDeadline: ({ startedAt, notFoundTimeoutMs, }: SwapStatusLimit) => number | undefined;
+/**
+ * @param status the status of a swap that is not final. `not_found` is a
+ * swap without a document.
+ * @returns the time from which a swap is no longer followed, or undefined
+ * when there is no limit
+ */
+export declare const getSwapFollowDeadline: ({ status, failedSince, ...limit }: SwapFollowLimit & {
+    status: SwapStatusOrNotFound;
+}) => number | undefined;

package/dist/services/internal/status/statusGuards.d.ts

@@ -0,0 +1,19 @@
+import type { StatusWsServerFrame, StatusWsTicket, SwapStatusDocument } from "../../../core/types/status";
+/**
+ * Checks the fields that the status code reads. Unknown action types, bridge
+ * names and extra fields are accepted.
+ */
+export declare const isSwapStatusDocument: (value: unknown) => value is SwapStatusDocument;
+/**
+ * Reads a status document like `isSwapStatusDocument`, but keeps a document
+ * whose status is a value that the API added later: the swap shows as in
+ * progress until it gets a known status.
+ */
+export declare const readSwapStatusDocument: (value: unknown) => SwapStatusDocument | undefined;
+export declare const isStatusWsTicket: (value: unknown) => value is StatusWsTicket;
+/**
+ * Reads a text frame of the status WebSocket
+ *
+ * @returns undefined for a frame that is not valid or not known
+ */
+export declare const parseStatusWsFrame: (raw: string) => StatusWsServerFrame | undefined;

package/dist/services/internal/status/statusHistory.d.ts

@@ -0,0 +1,35 @@
+import { HistoryTxType, type HistoryTransaction, type SwapTransactionHistory } from "../../../core/types/history";
+import { TransactionStatus } from "../../../core/types/transaction";
+import { type SwapStatusOrNotFound } from "./statusMapping";
+export declare const isNotSwapTransaction: (tx: HistoryTransaction) => tx is {
+    data: import("../../../core/types/history").FiatTransactionHistory;
+    txType: HistoryTxType.BUY;
+} | {
+    data: import("../../../core/types/history").SendTransactionHistory;
+    txType: HistoryTxType.SEND;
+};
+export declare const swapHistoryPendingStatuses: readonly TransactionStatus[];
+/**
+ * - `follow`: follow the status until it is final
+ * - `recheck`: request the status one time per app load
+ * - `none`: the status is final, cannot be requested or is too old
+ */
+type SwapHistoryStatusPlan = "follow" | "recheck" | "none";
+export declare const getSwapHistoryStatusPlan: (transaction: SwapTransactionHistory, now: number) => SwapHistoryStatusPlan;
+/**
+ * Returns the status that the history item got from the status API. It is
+ * undefined when the item has another status, for example after a failure of
+ * the source transaction in the wallet.
+ */
+export declare const getKnownSwapStatus: (transaction: Pick<SwapTransactionHistory, "status" | "statusSummary">) => SwapStatusOrNotFound | undefined;
+export interface SwapHistoryQueryParams {
+    /**
+     * Time of the transaction in milliseconds
+     */
+    startedAt: number;
+    notFoundTimeoutMs: number;
+    failedSince?: number;
+    depositTxVerificationSignature?: string;
+}
+export declare const getSwapHistoryQueryParams: (transaction: SwapTransactionHistory, transactionSignature?: string) => SwapHistoryQueryParams;
+export {};

package/dist/services/internal/status/statusKeys.d.ts

@@ -0,0 +1,8 @@
+import type { StatusKeys } from "../../../core/types/status";
+import type { SwapTransactionForStatus } from "../../../core/types/transaction";
+/**
+ * Returns the keys of the status request, or undefined when the status of the
+ * transaction cannot be requested
+ */
+export declare const getSwapStatusKeys: (transaction: Pick<SwapTransactionForStatus, "fromChain" | "transactionId" | "transactionIdForStatus" | "quoteId">) => StatusKeys | undefined;
+export declare const getSwapStatusKeyId: ({ quoteId, transactionId }: StatusKeys) => string;