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

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;

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

@@ -0,0 +1,73 @@
+import type { KnownSwapStatusActionStatus, StatusKeys, SwapStatus, SwapStatusAction, SwapStatusBridgeSourceTxHashes, SwapStatusDocument, SwapStatusSummary } from "../../../core/types/status";
+import { type TransactionParams, TransactionStatus } from "../../../core/types/transaction";
+export declare const SWAP_STATUS_NOT_FOUND = "not_found";
+export declare const SWAP_STATUS_NOT_FOUND_SLOW_AFTER_MS: number;
+export declare const SWAP_STATUS_NOT_FOUND_TIMEOUT_MS: number;
+export declare const SWAP_STATUS_FAILED_FOLLOW_MS: number;
+export declare const SWAP_STATUS_MAX_FOLLOW_AGE_MS: number;
+export declare const SWAP_STATUS_RECHECK_MAX_AGE_MS: number;
+export declare const SWAP_STATUS_NOT_FOUND_SLOW_POLL_INTERVAL_MS = 30000;
+export type SwapStatusOrNotFound = SwapStatus | typeof SWAP_STATUS_NOT_FOUND;
+export declare const isSwapStatus: (value: unknown) => value is SwapStatus;
+/**
+ * `failed` is not final: a failed bridge leg can be retried and reach
+ * `success` or `refunded`.
+ */
+export declare const isFinalSwapStatus: (status: SwapStatus) => boolean;
+export declare const getSwapTransactionStatus: (status: SwapStatus) => TransactionStatus;
+/**
+ * The status that the progress view of a swap shows. A `success` document
+ * wins over the local transaction, because the steps show it as delivered.
+ */
+export declare const getDisplayedSwapStatus: (transaction: Pick<TransactionParams, "error" | "sourceStatus"> | undefined, latestStatus: TransactionStatus | undefined, document: Pick<SwapStatusDocument, "status"> | undefined) => TransactionStatus;
+/**
+ * Returns the `squidTransactionStatus` value of the v2 status API, which is
+ * the value of the `swapStatus` widget event
+ */
+export declare const getLegacySwapStatus: (status: SwapStatusOrNotFound) => string;
+/**
+ * @returns the delay before the next status request in milliseconds, or
+ * undefined when the status is final
+ */
+export declare const getSwapStatusPollInterval: (status: SwapStatusOrNotFound) => number | undefined;
+/**
+ * @returns the time at which the swap started to fail, or undefined when the
+ * status is not `failed`
+ */
+export declare const getFailedSince: (status: SwapStatusOrNotFound | undefined, failedSince?: number) => number | undefined;
+export declare const getBridgeSourceTxHashes: (actions: Pick<SwapStatusAction, "bridgeType" | "sourceTxHash">[] | undefined) => SwapStatusBridgeSourceTxHashes | undefined;
+export declare const CHAINFLIP_SCAN_URL = "https://scan.chainflip.io";
+export declare const getChainflipExplorerUrl: (actions: Pick<SwapStatusAction, "type" | "swapId" | "depositChannelId" | "explorerUrl">[] | undefined) => string | undefined;
+export declare const isSameBridgeSourceTxHashes: (a: SwapStatusBridgeSourceTxHashes | undefined, b: SwapStatusBridgeSourceTxHashes | undefined) => boolean;
+export declare const getSwapStatusSummary: (document: SwapStatusDocument, failedSince?: number) => SwapStatusSummary;
+export interface SwapStatusSegment {
+    status: KnownSwapStatusActionStatus;
+    actions: SwapStatusAction[];
+}
+export interface SwapStatusSegments {
+    source: SwapStatusSegment;
+    bridge: SwapStatusSegment | undefined;
+    destination: SwapStatusSegment | undefined;
+    refund: SwapStatusAction | undefined;
+}
+/**
+ * Groups the actions of a document into the source, bridge and destination
+ * segments of the route.
+ *
+ * The status of a segment does not come from its own actions alone. The
+ * source action of some deposit routes stays `NOT_STARTED` for the whole
+ * swap, so a segment is `COMPLETED` when a later segment has started or when
+ * the swap was delivered.
+ */
+export declare const getSwapStatusSegments: (document: Pick<SwapStatusDocument, "status" | "actions">) => SwapStatusSegments;
+/**
+ * Checks if the funds of the user arrived and the swap is now in progress.
+ * Used by deposit address flows, where there is no wallet transaction to wait
+ * for.
+ *
+ * A document has a source `transactionId` only when the source transaction
+ * exists, and its actions can all stay `NOT_STARTED` for some time after
+ * that. The backend can echo the queried channel id as the `transactionId`,
+ * so that value does not count.
+ */
+export declare const isSourceDepositReceived: (document: Pick<SwapStatusDocument, "status" | "actions" | "transactionId">, keys: StatusKeys) => boolean;

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

@@ -0,0 +1,45 @@
+import type { SwapTransactionHistory } from "../../../core/types/history";
+import type { SwapStatusDocument, SwapStatusResult, SwapStatusSummary } from "../../../core/types/status";
+import { TransactionStatus } from "../../../core/types/transaction";
+import { type SwapStatusLimit } from "./statusFollow";
+/**
+ * `null` is a 404: the backend does not know the swap yet
+ */
+export type SwapStatusQueryData = SwapStatusDocument | null;
+export interface SwapStatusRefetchIntervalParams extends SwapStatusLimit {
+    document: SwapStatusQueryData | undefined;
+    isError: boolean;
+    failedSince?: number;
+    /**
+     * True while the status WebSocket delivers every change of the swap
+     */
+    isLive?: boolean;
+    /**
+     * The backend registers the deposit of a signed order only from a REST
+     * request with the signature, so a live `not_found` alone never ends
+     */
+    hasSignature?: boolean;
+    now: number;
+}
+export interface SwapStatusHistoryUpdate {
+    status: TransactionStatus;
+    statusSummary?: SwapStatusSummary;
+}
+/**
+ * The one merge rule for a status result, from a request or from a push
+ */
+export declare const mergeSwapStatus: (current: SwapStatusQueryData | undefined, result: SwapStatusResult) => SwapStatusQueryData;
+/**
+ * @returns the delay before the next status request in milliseconds, or
+ * false when the swap is no longer followed
+ */
+export declare const getSwapStatusRefetchInterval: ({ document, isError, startedAt, notFoundTimeoutMs, failedSince, isLive, hasSignature, now, }: SwapStatusRefetchIntervalParams) => number | false;
+export declare const shouldRetrySwapStatus: ({ now, ...limit }: SwapStatusLimit & {
+    now: number;
+}) => boolean;
+export declare const getSwapStatusRetryDelay: (failureCount: number, error: Error) => number;
+/**
+ * @returns what to write to the history item for the status data, or
+ * undefined when the item must not change
+ */
+export declare const getSwapStatusHistoryUpdate: (item: SwapTransactionHistory, data: SwapStatusQueryData, now: number, fetchedAt: number) => SwapStatusHistoryUpdate | undefined;

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

@@ -0,0 +1,40 @@
+import type { SwapStatusDocument } from "../../../core/types/status";
+import { type PatchedRouteActionResponse, TransactionStatus } from "../../../core/types/transaction";
+export type SwapStepStatus = "NOT_STARTED" | "IN_PROGRESS" | "COMPLETED" | "FAILED" | "WARNING";
+export type SwapRouteSegment = "source" | "bridge" | "destination";
+export type SwapProgressRouteAction = Pick<PatchedRouteActionResponse, "type" | "fromChain" | "toChain" | "coralV2Order">;
+export interface SwapRouteActionProgress<T extends SwapProgressRouteAction = SwapProgressRouteAction> {
+    action: T;
+    segment: SwapRouteSegment;
+    status: SwapStepStatus;
+}
+export interface SwapProgress<T extends SwapProgressRouteAction = SwapProgressRouteAction> {
+    /**
+     * The source transaction
+     */
+    pay: SwapStepStatus;
+    /**
+     * One entry per route action. Only the first unfinished action is
+     * `IN_PROGRESS`.
+     */
+    actions: SwapRouteActionProgress<T>[];
+    /**
+     * `COMPLETED` when the swap was delivered
+     */
+    receive: SwapStepStatus;
+}
+export declare const isCoralRouteAction: (action: SwapProgressRouteAction) => boolean;
+/**
+ * Resolves the progress of a swap from the route actions, the status
+ * document and the local status of the source transaction.
+ *
+ * @param sourceStatus the status of the source transaction in the wallet
+ * @param txStatus the status that the progress view shows
+ */
+export declare const getSwapProgress: <T extends SwapProgressRouteAction>({ actions, fromChainId, document, sourceStatus, txStatus, }: {
+    actions: T[];
+    fromChainId: string;
+    document: SwapStatusDocument | undefined;
+    sourceStatus: TransactionStatus | undefined;
+    txStatus: TransactionStatus | undefined;
+}) => SwapProgress<T>;

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

@@ -0,0 +1,157 @@
+import type { StatusKeys, StatusWsTicket, SwapStatusResult } from "../../../core/types/status";
+import { SwapStatusRequestError } from "./statusApi";
+export interface StatusWsSocketHandlers {
+    onOpen: () => void;
+    onMessage: (data: string) => void;
+    onClose: (code: number, reason: string) => void;
+}
+export interface StatusWsSocket {
+    send: (data: string) => void;
+    close: (code?: number) => void;
+}
+export interface StatusWsClientDependencies {
+    /**
+     * A ticket opens one connection, so this is called for each attempt
+     */
+    requestTicket: () => Promise<StatusWsTicket>;
+    /**
+     * Defaults to the global `WebSocket`
+     */
+    createSocket?: (url: string, handlers: StatusWsSocketHandlers) => StatusWsSocket;
+    now?: () => number;
+    random?: () => number;
+}
+export interface StatusWsConnectionEnd {
+    /**
+     * The close event of the socket. Without it, the attempt failed before the
+     * server closed the socket.
+     */
+    close?: {
+        code: number;
+        reason: string;
+    };
+    /**
+     * The error of the ticket request. Its `retryAfterMs` can be longer than
+     * the backoff limit.
+     */
+    ticketError?: Partial<Pick<SwapStatusRequestError, "httpStatus" | "retryAfterMs">>;
+    wasStable: boolean;
+    failedAttempts: number;
+    hasSubscribableKeys: boolean;
+}
+export type StatusWsEndAction = {
+    type: "disable";
+    warning?: string;
+} | {
+    type: "idle";
+} | {
+    type: "reconnectNow";
+} | {
+    type: "backoff";
+    retryAfterMs: number;
+};
+export interface StatusWsEndDecision {
+    action: StatusWsEndAction;
+    failedAttempts: number;
+    resetBackoff: boolean;
+}
+export declare const getStatusWsEndDecision: ({ close, ticketError, wasStable, failedAttempts, hasSubscribableKeys, }: StatusWsConnectionEnd) => StatusWsEndDecision;
+/**
+ * Follows the status of swaps over the status WebSocket.
+ *
+ * It holds one connection for all watched status keys. When the WebSocket
+ * cannot be used, no status keys are live and the owner of the client polls
+ * instead.
+ */
+export declare class StatusWsClient {
+    private readonly deps;
+    private readonly watches;
+    private readonly liveListeners;
+    private liveVersion;
+    private readonly closedKeys;
+    private readonly subscriptions;
+    private phase;
+    private disabled;
+    private connectionId;
+    private closingConnectionId;
+    private socket;
+    private subscriptionLimit;
+    private subscriptionCount;
+    private readyAt;
+    private backoffCount;
+    private failedAttempts;
+    private nextAttemptAt;
+    private ticketOrigin;
+    private removePolicyListener;
+    private outbox;
+    private sentAt;
+    private outboxTimer;
+    private readyTimer;
+    private reconnectTimer;
+    private idleTimer;
+    constructor(deps: StatusWsClientDependencies);
+    watch(keys: StatusKeys, onUpdate: (result: SwapStatusResult) => void, depositTxVerificationSignature?: string): () => void;
+    isLive(keys: StatusKeys): boolean;
+    /**
+     * Changes on each live change, for `useSyncExternalStore`
+     */
+    getLiveVersion(): number;
+    onLiveChange(listener: () => void): () => void;
+    /**
+     * Drops the connection and the disabled state, then connects again when
+     * there are watched status keys. For a change of the API or of the
+     * integrator.
+     */
+    reset(): void;
+    private createWatch;
+    private getInitialState;
+    private isEnded;
+    private hasWantedWatch;
+    private hasSubscribableWatch;
+    private notifyLiveChange;
+    private connect;
+    private open;
+    private handleMessage;
+    private handleReady;
+    private handleSubscribed;
+    private deliver;
+    private handleError;
+    private handleSubscriptionEnd;
+    /**
+     * @returns undefined when the status keys of the subscription are no longer
+     * watched, or when they are watched again without this subscription
+     */
+    private getSubscribedWatch;
+    private requeueCapped;
+    private subscribeQueued;
+    private send;
+    private flushOutbox;
+    /**
+     * Handles the end of a connection or of an attempt to connect
+     */
+    private endConnection;
+    /**
+     * Closes the socket and forgets the state of the connection. All status keys
+     * stop being live.
+     */
+    private dropConnection;
+    /**
+     * Stops the use of the WebSocket until `reset` or a page load
+     */
+    private disable;
+    /**
+     * Closes the connection when no status keys need it for some time, so that
+     * a new watch right after an unwatch uses the same connection. The failed
+     * attempts and the backoff stay, so that the limit applies across watches.
+     */
+    private syncIdle;
+    /**
+     * A content security policy that blocks the WebSocket URL does not change,
+     * so the client stops at the first violation. The socket only reports a
+     * close without a cause, and the event can arrive after that close.
+     */
+    private startPolicyListener;
+    private stopPolicyListener;
+    private isStable;
+    private now;
+}

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

@@ -1,7 +1,16 @@
+import { ChainData, Token } from "@0xsquid/squid-types";
 import { Networks as StellarNetwork } from "@stellar/stellar-sdk";
+import { StellarHorizonIssuedAsset, StellarHorizonNativeAsset, StellarIssuedToken, StellarToken } from "../../core/types/stellar";
+import { TrustLineAsset } from "../../core/types/tokens";
 export declare function isStellarAddressValid(address: string): boolean;
 export declare function getStellarNetwork(chainId: string): StellarNetwork | null;
 /**
  * Converts a Stellar address to a Soroban Contract address value
  */
 export declare function stellarAddressToScVal(addressString: string): import("@stellar/stellar-sdk").xdr.ScVal;
+export declare function getStellarTrustLineAsset(token: StellarIssuedToken): TrustLineAsset | null;
+export declare function isStellarToken(token: Token): token is StellarToken;
+export declare function isStellarIssuedToken(token: Token): token is StellarIssuedToken;
+export declare function getStellarHorizonApiUrl(chain: ChainData): string | null;
+export declare function isValidIssuedAsset(asset: unknown): asset is StellarHorizonIssuedAsset;
+export declare function isValidHorizonAsset(asset: unknown): asset is StellarHorizonNativeAsset | StellarHorizonIssuedAsset;

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

@@ -0,0 +1,42 @@
+/**
+ * @docs https://docs.tempo.xyz/protocol/fees/spec-fee-amm#2-feemanager-contract
+ */
+export declare const TEMPO_FEE_MANAGER_ADDRESS: "0xfeec000000000000000000000000000000000000";
+export declare const feeManagerAbi: readonly [{
+    readonly name: "userTokens";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "user";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+export declare const isTempoChain: (chainId: string | undefined) => boolean;
+/**
+ * Convert a gas fee amount from 18 decimals (attodollars)
+ * to 6-decimal TIP-20 stablecoin units (microdollars).
+ * All TIP-20 tokens on Tempo have 6 decimals.
+ * @docs https://docs.tempo.xyz/protocol/fees/spec-fee#fee-units
+ */
+export declare const convertTempoFeeToStablecoinUnits: (feeIn18Dec: bigint) => bigint;
+export type TempoFeeData = {
+    gasBalance: bigint;
+    /**
+     * The address of the resolved gas token.
+     * Either the account-preferred token address or the fromToken address.
+     */
+    gasTokenAddress: string;
+};
+export type ChainFeeParams = {
+    fromTokenPaysGasFees: boolean;
+    gasTokenBalanceWei: bigint;
+    /**
+     * Converts a raw fee (from gas estimator)
+     * into the correct unit for the resolved gas token.
+     * Handles the 18-dec to 6-dec conversion for Tempo.
+     */
+    normalizeFee: (rawFee: bigint) => bigint;
+};

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

@@ -1,30 +1,18 @@
-import { OnChainExecutionData, RouteResponse, SquidData, type ChainData, type StatusResponse } from "@0xsquid/squid-types";
-import { HistoryTransaction, SwapTransactionHistory } from "../../core/types/history";
-import { PatchedRouteActionResponse, SimplifiedRouteAction, SwapTransactionForHistoryStore, SwapTransactionForStatus, TransactionParams } from "../../core/types/transaction";
+import { OnChainExecutionData, RouteActionResponse, RouteResponse, SquidData, type ChainData } from "@0xsquid/squid-types";
+import { HistoryTransaction } from "../../core/types/history";
+import { PatchedRouteActionResponse, SimplifiedRouteAction, SwapTransactionForHistoryStore } from "../../core/types/transaction";
 export declare const formatTransactionHistoryDate: (transaction: SwapTransactionForHistoryStore | undefined) => {
     month: string;
     day: string;
 } | undefined;
-export declare const getAxelarExplorerTxUrl: (urlPrefix: string | undefined, routeType: string | undefined, txID: string) => string | undefined;
 export declare const getSourceExplorerTxUrl: (chain: ChainData | undefined, txID: string) => string | undefined;
-export declare const getMainExplorerUrl: (transaction?: TransactionParams) => any;
 export declare const formatDistance: (date: number | Date, baseDate: number | Date, options?: {
     includeSeconds?: boolean | undefined;
     addSuffix?: boolean | undefined;
     locale?: Locale | undefined;
 }) => string;
 export declare const formatSeconds: (seconds: number, secondsTemplate?: string, minutesTemplate?: string, hoursTemplate?: string) => string;
-/**
- * Remove the chainData from statusResponse to gain some storage space
- */
-export declare const formatSwapTxStatusResponseForStorage: (sr: StatusResponse | undefined) => SwapTransactionHistory["statusResponse"];
 export declare const simplifyRouteAction: (action: PatchedRouteActionResponse) => SimplifiedRouteAction;
-export declare const fetchSwapTransactionStatus: ({ transaction, integratorId, apiUrl, }: {
-    transaction?: SwapTransactionForStatus | undefined;
-    integratorId: string;
-    apiUrl: string;
-}) => Promise<StatusResponse>;
-export declare const compareTransactionIds: (idA: string, idB: string) => boolean;
 interface Locale {
     locale?: string;
 }
@@ -32,12 +20,14 @@ interface Locale {
  * Checks if the provided action is Coral bridge action
  */
 export declare function isCoralBridgeAction(action: SimplifiedRouteAction): boolean;
-export declare function sleep(ms: number): Promise<unknown>;
-export declare const isDepositRoute: (route?: RouteResponse["route"]) => boolean;
 /**
- * Checks if the route contains a Chainflip bridge action
+ * Determines if a given action completes as part of the user's source transaction.
+ * Action types like RFQ are fulfilled by a solver in a separate transaction,
+ * so they are NOT completed on source even if they share the same chain.
  */
-export declare function isChainflipBridgeTransaction(actions?: SimplifiedRouteAction[]): boolean;
+export declare function isActionCompletedOnSourceTx(action: Pick<RouteActionResponse, "type" | "fromChain" | "toChain">, fromChainId: string): boolean;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare const isChainflipDepositRoute: (route?: RouteResponse["route"]) => boolean;
 /**
  * Checks if a route is of type {@link OnChainExecutionData}
  *
@@ -45,11 +35,8 @@ export declare function isChainflipBridgeTransaction(actions?: SimplifiedRouteAc
  */
 export declare function isOnChainTxData(squidData: SquidData): squidData is OnChainExecutionData;
 /**
- * Checks if a route is of type deposit-with-signature
- *
- * deposit-with-signature routes are on-chain routes
- * that require a signature from the user to execute
+ * Checks if a route is of type DepositAddressDirectTransfer
  */
-export declare function isDepositWithSignatureTxData(squidData: SquidData): squidData is OnChainExecutionData;
+export declare function isDepositAddressDirectTransferRoute(squidData: SquidData): squidData is OnChainExecutionData;
 export declare function getHistoryTransactionId(tx: HistoryTransaction): string;
 export {};

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

@@ -1,64 +1,11 @@
-import { ChainType, type ChainData, type StatusResponse, type Token } from "@0xsquid/squid-types";
-import { UseQueryResult } from "@tanstack/react-query";
+import { ChainType } from "@0xsquid/squid-types";
 import { HistoryTransaction } from "../../core/types/history";
-import type { SimplifiedRouteAction, StepStatusGetterProps, SwapTransactionForStatus, TransactionParams } from "../../core/types/transaction";
-import { TransactionStatus, TransactionType } from "../../core/types/transaction";
-/**
- * Get the steps for a transaction
- * First step and second step are always the same
- * @param transaction
- * @param statusResponse
- * @returns {TransactionStepStatus[]}
- */
-export declare const getStepStatuses: ({ transaction, statusResponse, onlyFullStatusStep, }: StepStatusGetterProps) => TransactionStatus[];
-export declare const getHalfSuccessState: (status?: TransactionStatus) => TransactionStatus | undefined;
-export declare const getStepsInfos: ({ fromChain, toChain, fromToken, toToken, amount, txType, transaction, statusResponse, }: {
-    txType: TransactionType;
-    amount: string;
-    fromChain?: ChainData | undefined;
-    toChain?: ChainData | undefined;
-    fromToken?: Token | undefined;
-    toToken?: Token | undefined;
-    transaction?: TransactionParams | undefined;
-    statusResponse?: UseQueryResult<StatusResponse, unknown> | undefined;
-}) => {
-    label: string;
-    status: TransactionStatus;
-    subTitle?: string;
-    link?: string;
-}[];
-/**
- * Returns the status refetch interval of a Swap transaction
- * Some routes have a faster refetch interval (i.e Coral RFQ routes)
- *
- * @returns Refetch interval in milliseconds
- */
-export declare const getSwapTxStatusRefetchInterval: (transaction: Pick<SwapTransactionForStatus, "actions"> | undefined) => number;
 /**
  * Returns the status refetch interval of a Send transaction
  *
  * @returns Refetch interval in milliseconds
  */
 export declare const getSendTxStatusRefetchInterval: (chainType: ChainType) => number;
-export declare const chainflipMultihopBridgeType = "chainflipMultihop";
-/**
- * Some routes have special bridges, like CCTP or Chainflip
- * Squid API is using a different status endpoint to track status of these bridges
- * Only certain bridges are supported
- * @param transaction
- * @returns
- */
-export declare const getBridgeType: (actions?: SimplifiedRouteAction[]) => string | undefined;
-export declare const getTransactionStatus: (statusResponse: Pick<StatusResponse, "status" | "squidTransactionStatus">) => string | undefined;
-/**
- * Checks statusResponse of a transaction and returns the end status (if any)
- * If transaction status is not an end status, means the transaction is still pending
- *
- * End statuses are success, refunded, or error
- */
-export declare const getTransactionEndStatus: ({ statusResponse, }: {
-    statusResponse: StatusResponse;
-}) => TransactionStatus | undefined;
 export declare function isHistoryTransactionPending({ txType, data, }: HistoryTransaction): boolean;
 export declare function isHistoryTransactionFailed({ txType, data, }: HistoryTransaction): boolean;
 export declare function isHistoryTransactionWarning({ txType, data, }: HistoryTransaction): boolean;

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

@@ -0,0 +1,10 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const isOptionalString: (value: unknown) => value is string | undefined;
+export declare const isOneOf: <T>(values: readonly T[], value: unknown) => value is T;
+export declare const isDefined: <T>(value: T | undefined) => value is T;
+/**
+ * @returns undefined when the text is not valid JSON
+ */
+export declare const parseJson: (text: string) => unknown;
+export declare const readString: (value: unknown) => string;
+export declare const readOptionalString: (value: unknown) => string | undefined;

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

@@ -0,0 +1,19 @@
+import type { AppConfig } from "../../core/types/config";
+import type { WidgetEventMap } from "../../core/types/event";
+/**
+ * Parses URL search params into an initialAssets config object.
+ *
+ * Supports two formats:
+ * - Legacy:  ?chains=fromId,toId&tokens=fromAddr,toAddr
+ * - Pretty:  ?fromChain=ethereum&fromToken=eth&toChain=polygon&toToken=usdc
+ *   - Collapsed chain/token: when both from/to chains or tokens are the same,
+ *     they are collapsed into a single param:
+ *       - ?chain=ethereum -> from and to chains are both ethereum
+ *       - ?token=eth -> from and to tokens are both eth
+ */
+export declare const parseInitialAssetsFromUrl: (searchParams: URLSearchParams) => AppConfig["initialAssets"];
+/**
+ * Builds URL search params from a `swapParamsChanged` event detail.
+ * Uses the pretty format, collapsing chain/token params when both sides match.
+ */
+export declare const buildUrlSearchParamsFromSwapEvent: (swapParams: WidgetEventMap["swapParamsChanged"]) => URLSearchParams;

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

@@ -2,6 +2,7 @@ import type { ChainData, Token } from "@0xsquid/squid-types";
 import { ChainType } from "@0xsquid/squid-types";
 import { Connector } from "@wagmi/core";
 import { IBitcoinContextData } from "../../core/providers/BitcoinProvider";
+import { ICantonContextData } from "../../core/providers/CantonProvider";
 import { ICosmosContextData } from "../../core/providers/CosmosProvider";
 import { IEvmContextData } from "../../core/providers/EvmProvider";
 import { ISolanaContextData } from "../../core/providers/SolanaProvider";
@@ -17,14 +18,9 @@ type FormatHashParams = {
 export declare const formatHash: ({ chainType, hash }: FormatHashParams) => string;
 export declare const isWalletAddressValid: (chainData?: ChainData, address?: string) => boolean;
 export declare const redirectToExtensionsStore: (wallet: Wallet) => void;
-/**
- * Dynamically accesses a nested property of an object based on a dot-separated string path.
- * Returns the value of the property if found, otherwise undefined.
- * e.g. "xfi.keplr" will return window.xfi.keplr
- */
-export declare const accessProperty: (object: Record<string, any>, path: string) => any;
 export declare const definedInWindow: (path: string | undefined, clientWindow: Window | undefined) => boolean;
 export declare const populateWallets: <T extends Wallet>(window: Window | undefined, wallets: T[]) => T[];
+export declare const buildFallbackWallets: (discovered: Wallet[]) => Wallet[];
 /**
  * Get the base chain to connect to
  * If only one chain type is selected, use that chain type
@@ -74,6 +70,7 @@ interface ConnectWalletMutations {
     connectSui: ISuiContextData["connectSui"];
     connectXrpl: IXrplContextData["connectXrpl"];
     connectStellar: IStellarContextData["connectStellar"];
+    connectCanton: ICantonContextData["connectCanton"];
 }
 type ConnectWalletParams = {
     wallet: Wallet;

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

@@ -1,4 +1,5 @@
 import { Token } from "@0xsquid/squid-types";
+import { TrustLineAsset } from "../../core/types/tokens";
 import { XrplNetwork, XrplPaymentTx, XrplTrustSetTx } from "../../core/types/xrpl";
 /**
  * Validates that a given address is a valid XRPL address.
@@ -15,3 +16,4 @@ export declare function buildXrplTrustSetTx({ amount, sourceAddress, token, }: {
 }): XrplTrustSetTx;
 export declare function getXrplNetwork(chainId: string): XrplNetwork | null;
 export declare function parseXrplPaymentTx(data: unknown): XrplPaymentTx | null;
+export declare function parseXrplTokenAddress(address: string): TrustLineAsset | null;