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

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

@@ -1,10 +1,11 @@
 import type { Squid } from "@0xsquid/sdk";
 import { ChainData, ChainType, Token } from "@0xsquid/squid-types";
 import { QueryClient } from "@tanstack/react-query";
+import { assetsBaseUrl } from "../../core/constants";
 import type { AppConfig } from "../../core/types/config";
 import { SwapDirection, SwapParams } from "../../core/types/swap";
 import type { TokenGroup, TokenWithBalance } from "../../core/types/tokens";
-export declare const assetsBaseUrl = "https://raw.githubusercontent.com/0xsquid/assets/main";
+export { assetsBaseUrl };
 export declare const shareSubgraphId: (token1: Token, token2: Token) => boolean;
 /**
  * Check if `tokenToCheck` shares any subgraph id with the tokens being compared
@@ -62,8 +63,8 @@ export declare const getNewSwapParamsFromInput: ({ inputParams, initialSwapRoute
     connectedSourceAddress?: string | undefined;
 }) => SwapParams;
 export declare const sortAllTokens: (tokenA: Pick<Token, "address" | "symbol" | "chainId">, tokenB: Pick<Token, "address" | "symbol" | "chainId">) => number;
-export declare const findToken: (tokens: any[], chainId?: string, address?: string) => any;
-export declare const findNativeToken: (tokens: Token[], chain?: Pick<ChainData, "chainId"> & {
+export declare const findToken: <T extends Pick<Token, "chainId" | "address">>(tokens: T[], chainId?: string, address?: string) => T | undefined;
+export declare const findNativeToken: (tokens: Token[], chain: Pick<ChainData, "chainId"> & {
     nativeCurrency: Pick<ChainData["nativeCurrency"], "symbol">;
 }) => Token | undefined;
 export declare const normalizeIbcAddress: (address: string) => string;
@@ -108,7 +109,16 @@ export type AssetsColors = {
     }>;
 };
 export declare function fetchAssetsColors(): Promise<AssetsColors>;
-export declare function initializeSquidWithAssetsColors(squid: Squid, assetsColors: AssetsColors): void;
+export declare function isSupportedChainType(chainType: string): chainType is ChainType;
+/**
+ * Normalizes SDK data after each init/refetch before the rest of hooks consumes it.
+ *
+ * - Removes chains whose chainType is not supported by the local package.
+ * - Drops tokens for those removed chains.
+ * - Converts Evmos chains/tokens to EVM.
+ * - Applies optional asset colors.
+ */
+export declare function initializeSquidData(squid: Squid, assetsColors?: AssetsColors): void;
 export declare function isEmptyObject(obj: Record<string, unknown> | undefined): boolean;
 export declare const normalizeTokenSymbol: (symbol: string) => string;
 export declare const areTokenSymbolsCompatible: (symbol1: string, symbol2: string) => boolean;

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,10 +1,8 @@
-import { Squid } from "@0xsquid/sdk";
-import { ChainData } from "@0xsquid/squid-types";
 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";
-import { AssetsColors } from "./assetsService";
+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[];
@@ -90,61 +88,3 @@ export declare const getInitialChainIdFromConfig: ({ config, direction, chains,
     direction: SwapDirection;
     chains: Chain[] | undefined;
 }) => string | undefined;
-interface InitSdkReturn {
-    isInitialized: boolean;
-    newConfig: AppConfig;
-    squid?: Squid;
-    maintenanceMode?: {
-        active: boolean;
-        message: string | undefined;
-    };
-    shouldResetSwapRouteStore?: boolean;
-    assetsColors: AssetsColors | null;
-}
-export declare function initializeConfig(config: AppConfig): Promise<InitSdkReturn | null>;
-export declare function buildWagmiConfig({ chains, isInitialized, }: {
-    chains: ChainData[];
-    isInitialized: boolean;
-}): Promise<import("wagmi").Config | import("wagmi").Config<readonly [{
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Etherscan";
-            readonly url: "https://etherscan.io";
-            readonly apiUrl: "https://api.etherscan.io/api";
-        };
-    };
-    contracts: {
-        readonly ensRegistry: {
-            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
-        };
-        readonly ensUniversalResolver: {
-            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
-            readonly blockCreated: 19258213;
-        };
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 14353601;
-        };
-    };
-    id: 1;
-    name: "Ethereum";
-    nativeCurrency: {
-        readonly name: "Ether";
-        readonly symbol: "ETH";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://cloudflare-eth.com"];
-        };
-    };
-    sourceId?: number | undefined;
-    testnet?: boolean | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: import("viem").ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
-}], {
-    1: import("viem").HttpTransport;
-}>>;
-export {};

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;