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

package/dist/core/canton/cantonConnector.d.ts

@@ -0,0 +1,32 @@
+import { type CantonClient } from "@sigilry/dapp";
+import type { CantonAccount, CantonConnectResult, CantonCip103Connector, CantonConnectorEvent, CantonConnectorEventHandler, CantonLedgerApiParams, CantonPrepareExecuteAndWaitResult, CantonPrepareExecuteParams, CantonTransferParams, CantonTransferResult } from "../types/canton";
+import { AnnouncedCantonProvider } from "./cip103Client";
+/**
+ * Browser-extension Canton connector: wraps one discovered CIP-103 provider
+ * (bound to its announce `target`) and exposes the lifecycle methods.
+ */
+export declare class CantonBrowserConnector implements CantonCip103Connector {
+    readonly kind = "cip103";
+    readonly providerId: string;
+    readonly name: string;
+    readonly target: string | undefined;
+    private readonly client;
+    private readonly listeners;
+    private _accounts;
+    constructor(provider: AnnouncedCantonProvider, win?: Window, client?: CantonClient);
+    get accounts(): CantonAccount[];
+    get address(): string | undefined;
+    connect(): Promise<CantonConnectResult>;
+    /** Silent connect: read accounts without prompting; throws if not connected. */
+    autoConnect(): Promise<CantonConnectResult>;
+    disconnect(): Promise<void>;
+    ledgerApi<T = unknown>(params: CantonLedgerApiParams): Promise<T>;
+    prepareExecuteAndWait(params: CantonPrepareExecuteParams): Promise<CantonPrepareExecuteAndWaitResult>;
+    getAccounts(): Promise<CantonAccount[]>;
+    getBalances(partyId: string): Promise<Record<string, string>>;
+    transfer(params: CantonTransferParams): Promise<CantonTransferResult>;
+    on<E extends CantonConnectorEvent>(event: E, handler: CantonConnectorEventHandler<E>): void;
+    off<E extends CantonConnectorEvent>(event: E, handler: CantonConnectorEventHandler<E>): void;
+    private emit;
+    private refreshAccounts;
+}

package/dist/core/canton/cip103Client.d.ts

@@ -0,0 +1,20 @@
+export declare const CANTON_REQUEST_PROVIDER_EVENT = "canton:requestProvider";
+export declare const CANTON_ANNOUNCE_PROVIDER_EVENT = "canton:announceProvider";
+export interface AnnouncedCantonProvider {
+    /** Stable identifier for the wallet/extension. */
+    id: string;
+    /** Display name for pickers. */
+    name: string;
+    /** Optional icon (data URL or https URL). */
+    icon?: string;
+    /** Routing key for the postMessage transport (defaults to `id`). */
+    target?: string;
+}
+/**
+ * CIP-103 browser-wallet discovery (EIP-6963-style).
+ * The wallet dispatches `canton:announceProvider` and dApps
+ * dispatch `canton:requestProvider` to ask installed wallets to re-announce.
+ * Each announcement carries a `target` we route through Sigilry's `WindowTransport`,
+ * so multiple extensions coexist without contending on the `window.canton` global.
+ */
+export declare function discoverCantonProviders(timeoutMs?: number, win?: Window): Promise<AnnouncedCantonProvider[]>;

package/dist/core/canton/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class CantonConnectionCancelledError extends Error {
+    readonly code = 4001;
+    constructor();
+}

package/dist/core/canton/injectedCantonProvider.d.ts

@@ -0,0 +1,31 @@
+import type { CantonClient, SpliceProvider } from "@sigilry/dapp";
+import type { ConnectorID } from "../types/wallet";
+export interface InjectedCantonWalletConfig {
+    connectorId: ConnectorID;
+    name: string;
+    icon?: string;
+    /** Dot-path to the injected CIP-103 provider on `window` (e.g. `nightly.canton`). */
+    windowPath: string;
+}
+/**
+ * CIP-103 wallets that expose their provider as an injected `window` global
+ * instead of participating in the `canton:announceProvider` discovery protocol.
+ * Add an entry to support a new one.
+ */
+export declare const INJECTED_CANTON_WALLETS: InjectedCantonWalletConfig[];
+export interface DiscoveredInjectedCantonWallet {
+    config: InjectedCantonWalletConfig;
+    provider: SpliceProvider;
+}
+/**
+ * Adapts an injected CIP-103 `SpliceProvider` (the normative `request` API) to
+ * the {@link CantonClient} surface consumed by `CantonBrowserConnector`, so
+ * injected wallets reuse the same connector as announce-discovered ones.
+ */
+export declare function cantonClientFromSpliceProvider(provider: SpliceProvider): CantonClient;
+/**
+ * Detect installed injected Canton wallets by walking each registered
+ * `windowPath`, mirroring the `definedInWindow` install check used for other
+ * non-autodiscovered wallets.
+ */
+export declare function discoverInjectedCantonWallets(win?: Window): DiscoveredInjectedCantonWallet[];

package/dist/core/canton/loopCantonConnector.d.ts

@@ -0,0 +1,38 @@
+import type { CantonAccount, CantonConnectResult, CantonConnectorEvent, CantonConnectorEventHandler, CantonLoopConnector, CantonTransferParams, CantonTransferResult, CantonTransferUpdate } from "../types/canton";
+type LoopModule = typeof import("@fivenorth/loop-sdk");
+export declare function parseLoopTransferUpdate(value: unknown, commandId: string): CantonTransferUpdate | undefined;
+export declare class LoopCantonConnector implements CantonLoopConnector {
+    private loadSdk;
+    readonly kind = "loop";
+    readonly providerId = "canton-loop";
+    readonly name = "Loop";
+    readonly target: undefined;
+    private module?;
+    private initialization?;
+    private provider?;
+    private pendingConnection?;
+    private connectionStart;
+    private transfers;
+    private listeners;
+    constructor(loadSdk?: () => Promise<LoopModule>);
+    get accounts(): CantonAccount[];
+    get address(): string | undefined;
+    connect(): Promise<CantonConnectResult>;
+    autoConnect(): Promise<CantonConnectResult>;
+    cancelConnect(): void;
+    disconnect(): Promise<void>;
+    getAccounts(): Promise<CantonAccount[]>;
+    getBalances(partyId: string): Promise<Record<string, string>>;
+    transfer(params: CantonTransferParams): Promise<CantonTransferResult>;
+    on<E extends CantonConnectorEvent>(event: E, handler: CantonConnectorEventHandler<E>): void;
+    off<E extends CantonConnectorEvent>(event: E, handler: CantonConnectorEventHandler<E>): void;
+    private emit;
+    private initialize;
+    private startConnection;
+    private acceptConnection;
+    private rejectConnection;
+    private requireProvider;
+    private submitTransfer;
+}
+export declare const loopCantonConnector: LoopCantonConnector;
+export {};

package/dist/core/client/index.d.ts

@@ -13,6 +13,7 @@ type ChainTypeToClient = {
     [ChainType.SUI]: SuiClient;
     [ChainType.XRPL]: XrplRpcClient;
     [ChainType.STELLAR]: StellarRpcClient;
+    [ChainType.CANTON]: null;
 };
 export declare function getClient<T extends ChainType>(chain: ChainData): Promise<ChainTypeToClient[T]>;
 export {};

package/dist/core/connectors/bitcoin/wallets/keplr.d.ts

@@ -8,4 +8,7 @@ export declare class KeplrConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }

package/dist/core/connectors/bitcoin/wallets/phantom.d.ts

@@ -22,6 +22,8 @@ export declare class PhantomConnector implements BitcoinConnector {
     sendBTC(to: string, amount: number): Promise<{
         txHash: string;
     }>;
-    private signPsbt;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }
 export {};

package/dist/core/connectors/bitcoin/wallets/unisat.d.ts

@@ -1,7 +1,19 @@
 import { BitcoinConnector } from "../../../../core/types/bitcoin";
+interface UnisatSignPsbtOptions {
+    autoFinalized?: boolean;
+    toSignInputs?: Array<{
+        index: number;
+        address?: string;
+        publicKey?: string;
+        sighashTypes?: number[];
+        disableTweakSigner?: boolean;
+    }>;
+}
 interface UnisatProvider {
     sendBitcoin: (to: string, amount: number) => Promise<string>;
     requestAccounts: () => Promise<string[]>;
+    signPsbt: (psbtHex: string, options?: UnisatSignPsbtOptions) => Promise<string>;
+    pushPsbt: (psbtHex: string) => Promise<string>;
 }
 export declare class UnisatConnector implements BitcoinConnector {
     get getProvider(): UnisatProvider;
@@ -11,5 +23,8 @@ export declare class UnisatConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }
 export {};

package/dist/core/constants.d.ts

@@ -21,6 +21,7 @@ export declare const nativeBitcoinTokenAddress = "satoshi";
 export declare const nativeSuiTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
 export declare const nativeXrplTokenAddress = "xrp";
 export declare const nativeStellarTokenAddress = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
+export declare const nativeCantonTokenAddress = "DSO::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc";
 export declare const defaultSlippage: SlippageOption;
 export declare const destinationAddressResetValue = "null";
 export declare const fallbackAddressResetValue = "null";
@@ -28,6 +29,7 @@ export declare const gasRefundMultiplier = 25;
 export declare const internalSquidApiBaseUrl = "https://app.squidrouter.com/api";
 export declare const XAMAN_API_URL: string;
 export declare const TOKEN_PRICE_API_URL: string;
+export declare const CANTON_AMULET_REGISTRY_URL: string;
 export declare const DEFAULT_ROUTE_REFETCH_INTERVAL = 30000;
 export declare const SOLANA_RPC_URL = "https://meredith-ute2ko-fast-mainnet.helius-rpc.com";
 export declare const INTEGRATOR_ID = "squid-widget-playground-local-cd33cba6-7e12-4fcc-8d5d-35e286f655ea";
@@ -69,6 +71,11 @@ export declare const CHAIN_IDS: {
     readonly SONEIUM: "1868";
     readonly PEAQ: "3338";
     readonly HEDERA: "295";
+    readonly MANTRA: "5888";
+    readonly CITREA: "4114";
+    readonly TEMPO: "4217";
+    readonly ARC: "5042";
+    readonly KUB: "96";
     readonly BITCOIN: "bitcoin";
     readonly SOLANA: "solana-mainnet-beta";
     readonly SUI: "sui-mainnet";
@@ -77,7 +84,9 @@ export declare const CHAIN_IDS: {
     readonly XRPL_TESTNET: "xrpl-testnet";
     readonly STELLAR: "stellar-mainnet";
     readonly STELLAR_TESTNET: "stellar-testnet";
+    readonly CANTON: "canton";
 };
+export declare const zeroAllowanceResetTokens: Set<string>;
 export declare const chainTypeToDefaultChainIdMap: Record<ChainType, string>;
 export declare const chainTypeToNativeTokenAddressMap: Record<ChainType, string>;
 export declare const defaultConfigValues: AppConfig;
@@ -85,7 +94,3 @@ export declare enum EvmPriorityConnectors {
     Safe = "safe",
     LedgerLive = "ledgerLive"
 }
-export declare const transactionRefundedStatuses: string[];
-export declare const transactionErrorStatuses: string[];
-export declare const transactionSuccessStatuses: string[];
-export declare const transactionEndStatuses: string[];

package/dist/core/externalLinks.d.ts

@@ -1 +1 @@
-export declare const squidApiBaseUrl = "https://api.uatsquidrouter.com";
+export declare const squidApiBaseUrl = "https://v2.api.squidrouter.com";

package/dist/core/fallbackWallets.d.ts

@@ -0,0 +1,16 @@
+import { ChainType } from "@0xsquid/squid-types";
+import type { WalletLinks } from "./types/wallet";
+export type FallbackWalletConfig = {
+    chainType: ChainType;
+    id: string;
+    name: string;
+    connectorName: string;
+    icon: string;
+    links: WalletLinks;
+};
+/**
+ * Wallets to show regardless of whether they're detected.
+ * Useful when we want to link to the browser extension store
+ * for wallets that are automatically discovered (i.e. EVM, SOLANA, CANTON...)
+ */
+export declare const fallbackWallets: FallbackWalletConfig[];

package/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-export { CHAIN_IDS, chainTypeToNativeTokenAddressMap, chainTypeToZeroAddressMap, DEFAULT_LOCALE, DEFAULT_ROUTE_REFETCH_INTERVAL, destinationAddressResetValue, fallbackAddressResetValue, nativeBitcoinTokenAddress, nativeCosmosTokenAddress, nativeEvmTokenAddress, nativeSolanaTokenAddress, nativeStellarTokenAddress, nativeSuiTokenAddress, nativeXrplTokenAddress, } from "./constants";
+export { CHAIN_IDS, DEFAULT_LOCALE, DEFAULT_ROUTE_REFETCH_INTERVAL, chainTypeToNativeTokenAddressMap, chainTypeToZeroAddressMap, destinationAddressResetValue, fallbackAddressResetValue, nativeBitcoinTokenAddress, nativeCantonTokenAddress, nativeCosmosTokenAddress, nativeEvmTokenAddress, nativeSolanaTokenAddress, nativeStellarTokenAddress, nativeSuiTokenAddress, nativeXrplTokenAddress, } from "./constants";
 export { CosmosProvider, useCosmosContext } from "./providers/CosmosProvider";
 export { QueryKeys } from "./queries/queries-keys";
 export * from "./types";

package/dist/core/providers/CantonProvider.d.ts

@@ -0,0 +1,19 @@
+import { ChainType } from "@0xsquid/squid-types";
+import { UseMutationResult } from "@tanstack/react-query";
+import React, { ReactNode } from "react";
+import { CantonConnector } from "../types/canton";
+import { CantonWallet, ConnectWalletResult } from "../types/wallet";
+export interface ICantonContextData {
+    connectCanton: UseMutationResult<ConnectWalletResult<ChainType.CANTON>, unknown, {
+        wallet: CantonWallet;
+    }, unknown>;
+    disconnectCanton: () => Promise<void>;
+    autoConnectCanton: () => Promise<void>;
+    signer: CantonConnector | undefined;
+    wallets: CantonWallet[];
+}
+export declare const CantonContext: React.Context<ICantonContextData | undefined>;
+export declare const CantonProvider: React.FC<{
+    children: ReactNode;
+}>;
+export declare const useCantonContext: () => ICantonContextData;

package/dist/core/queries/queries-keys.d.ts

@@ -1,6 +1,7 @@
 import { ChainType, RouteResponse } from "@0xsquid/squid-types";
 import { HistoryTransaction } from "../../core/types/history";
 import { AppConfig, SlippageOption } from "../types/config";
+import type { StatusKeys } from "../types/status";
 import { SwapDirection } from "../types/swap";
 import { Timeframe, TokenWithBalance } from "../types/tokens";
 export declare enum QueryKeys {
@@ -13,7 +14,7 @@ export declare enum QueryKeys {
     AllTokensBalance = "allTokensBalance",
     Transactions = "transactions",
     Transaction = "transaction",
-    SwapTransactionStatus = "swapTransactionStatus",
+    SwapStatus = "swapStatus",
     SendTransactionStatus = "sendTransactionStatus",
     RouteApproved = "routeApproved",
     SendTransactionGas = "sendTransactionGas",
@@ -34,6 +35,8 @@ export declare enum QueryKeys {
     XrplAccountActivatedInfo = "xrplAccountActivatedInfo",
     FiatToCryptoPaymentMethods = "fiatToCryptoPaymentMethods",
     Stellar = "stellar",
+    StellarTrustLine = "stellarTrustLine",
+    IsStellarTrustLineApproved = "isStellarTrustLineApproved",
     StellarAccountActivatedInfo = "stellarAccountActivatedInfo",
     Hedera = "hedera",
     IsHederaTokenAssociated = "isHederaTokenAssociated"
@@ -54,12 +57,12 @@ export declare const keys: () => {
     tokenData: (token?: TokenWithBalance) => (string | undefined)[];
     balance: (chainId?: number | string, tokenAddress?: string, userAddress?: string) => (string | number | undefined)[];
     allTokensBalance: (address: string | undefined, chainType: ChainType | undefined, direction?: SwapDirection) => (string | undefined)[];
-    transaction: (fromChainId: string | undefined, toChainId: string | undefined, toTokenAddress: string | undefined, fromTokenAddress: string | undefined, price: string | undefined, slippage: SlippageOption | undefined, getGasOnDestination: boolean | undefined, sourceUserAddress: string | undefined, degenMode: boolean | undefined, destinationAddress: string | undefined, fallbackAddress: string | undefined, quoteOnly: boolean | undefined, fromChainType: ChainType | undefined, preHook: AppConfig["preHook"] | undefined, postHook: AppConfig["postHook"] | undefined, overrideGasRefundAddress: AppConfig["overrideGasRefundAddress"] | undefined) => (string | number | boolean | Omit<import("@0xsquid/squid-types").Hook, "fundAmount" | "fundToken"> | undefined)[];
-    swapTransactionStatus: (transactionId: string | undefined) => (string | undefined)[];
+    transaction: (fromChainId: string | undefined, toChainId: string | undefined, toTokenAddress: string | undefined, fromTokenAddress: string | undefined, price: string | undefined, slippage: SlippageOption | undefined, sourceUserAddress: string | undefined, degenMode: boolean | undefined, destinationAddress: string | undefined, fallbackAddress: string | undefined, quoteOnly: boolean | undefined, fromChainType: ChainType | undefined, preHook: AppConfig["preHook"] | undefined, postHook: AppConfig["postHook"] | undefined, overrideGasRefundAddress: AppConfig["overrideGasRefundAddress"] | undefined) => (string | number | boolean | Omit<import("@0xsquid/squid-types").Hook, "fundAmount" | "fundToken"> | undefined)[];
+    swapStatus: (statusKeys: StatusKeys | undefined) => (string | null)[];
     fiatToCryptoStatus: (transactionId?: string) => (string | undefined)[];
     sendTransactionStatus: (txHash: string | undefined, chainId: string | undefined) => (string | undefined)[];
     allTransactionsStatus: (transactions: HistoryTransaction[] | undefined) => string[];
-    routeApproved: (routeData: RouteResponse["route"] | undefined, allowanceInWei: bigint | undefined) => (string | undefined)[];
+    routeApproved: (routeData: RouteResponse["route"] | undefined, allowanceInWei: bigint | undefined, isAllowanceQueryEnabled: boolean | undefined, hasAllowance: boolean | undefined) => (string | boolean | undefined)[];
     sendTransactionGas: (chainId: string | undefined, tokenAddress: string | undefined, from: string | undefined) => (string | undefined)[];
     ensData: (address?: string) => (string | undefined)[];
     ensSearch: (query?: string) => (string | undefined)[];
@@ -71,6 +74,8 @@ export declare const keys: () => {
     xrplTrustLine: (tokenAddress: string | undefined, chainId: string | undefined, address: string | undefined) => (string | undefined)[];
     isXrplTrustLineApproved: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined, tokenAddress: string | undefined, trustLineLimit: string | undefined, amountToApprove: bigint | undefined) => (string | undefined)[];
     xrplAccountActivatedInfo: (destinationAddress: string | undefined, toChainId: string | undefined, toChainType: ChainType | undefined) => (string | undefined)[];
+    stellarTrustLine: (tokenAddress: string | undefined, chainId: string | undefined, address: string | undefined) => (string | undefined)[];
+    isStellarTrustLineApproved: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined, tokenAddress: string | undefined, trustLineLimit: string | undefined, amountToApprove: bigint | undefined) => (string | undefined)[];
     stellarAccountActivatedInfo: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined) => (string | undefined)[];
     isHederaTokenAssociated: (address: string | undefined, chainId: string | undefined, chainType: ChainType | undefined, tokenAddress: string | undefined) => (string | undefined)[];
 };

package/dist/core/queries/queryClient.d.ts

@@ -0,0 +1,2 @@
+import { QueryClient } from "@tanstack/react-query";
+export declare const queryClient: QueryClient;

package/dist/core/types/bitcoin.d.ts

@@ -2,6 +2,9 @@ export interface BitcoinConnector {
     sendBTC(to: string, amount: number): Promise<{
         txHash: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
     requestAccount(): Promise<{
         address: string;
     }>;

package/dist/core/types/canton.d.ts

@@ -0,0 +1,92 @@
+import type { CantonClient } from "@sigilry/dapp";
+import type { Token } from "./tokens";
+export interface CantonLedgerApiParams {
+    requestMethod: "get" | "post" | "patch" | "put" | "delete";
+    resource: string;
+    body?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    path?: Record<string, unknown>;
+}
+export interface CantonAccount {
+    partyId: string;
+    primary?: boolean;
+    hint?: string;
+    namespace?: string;
+    networkId?: string;
+}
+export interface CantonInstrument {
+    admin: string;
+    id: string;
+}
+export interface CantonHolding {
+    contractId: string;
+    instrument: CantonInstrument;
+    amount: string;
+    locked: boolean;
+}
+export interface CantonDisclosedContract {
+    templateId?: string;
+    contractId?: string;
+    createdEventBlob: string;
+    synchronizerId?: string;
+}
+export type CantonPrepareExecuteParams = Parameters<CantonClient["prepareExecuteAndWait"]>[0];
+export type CantonPrepareExecuteAndWaitResult = Awaited<ReturnType<CantonClient["prepareExecuteAndWait"]>>;
+export interface CantonConnectorEventMap {
+    connect: [address: string];
+    disconnect: [];
+}
+export interface CantonTransferParams {
+    sender: string;
+    receiver: string;
+    amount: string;
+    token: Token;
+    memo: string;
+    nowMs: number;
+}
+export type CantonTransferResult = {
+    status: "completed";
+    commandId: string;
+    updateId: string;
+};
+export type CantonTransferUpdate = Extract<CantonTransferResult, {
+    status: "completed";
+}> | {
+    status: "failed";
+    commandId: string;
+    message: string;
+};
+export interface CantonLedgerReader {
+    ledgerApi<T = unknown>(params: CantonLedgerApiParams): Promise<T>;
+}
+export type CantonConnectorEvent = keyof CantonConnectorEventMap;
+export type CantonConnectorEventHandler<E extends CantonConnectorEvent> = (...args: CantonConnectorEventMap[E]) => void;
+export interface CantonConnectResult {
+    address: string;
+    accounts: CantonAccount[];
+}
+interface CantonConnectorBase {
+    readonly providerId: string;
+    readonly name: string;
+    readonly target: string | undefined;
+    connect(): Promise<CantonConnectResult>;
+    autoConnect(): Promise<CantonConnectResult>;
+    disconnect(): Promise<void>;
+    cancelConnect?(): void;
+    getBalances(partyId: string): Promise<Record<string, string>>;
+    transfer(params: CantonTransferParams): Promise<CantonTransferResult>;
+    getAccounts(): Promise<CantonAccount[]>;
+    on<E extends CantonConnectorEvent>(event: E, handler: CantonConnectorEventHandler<E>): void;
+    off<E extends CantonConnectorEvent>(event: E, handler: CantonConnectorEventHandler<E>): void;
+    readonly accounts: CantonAccount[];
+    readonly address: string | undefined;
+}
+export interface CantonCip103Connector extends CantonConnectorBase, CantonLedgerReader {
+    readonly kind: "cip103";
+    prepareExecuteAndWait(params: CantonPrepareExecuteParams): Promise<CantonPrepareExecuteAndWaitResult>;
+}
+export interface CantonLoopConnector extends CantonConnectorBase {
+    readonly kind: "loop";
+}
+export type CantonConnector = CantonCip103Connector | CantonLoopConnector;
+export {};

package/dist/core/types/config.d.ts

@@ -4,10 +4,16 @@ export type TokenConfig = {
     address: string;
     chainId: string;
 };
+export type NamedTokenConfig = {
+    networkName: string;
+    /**
+     * When omitted, a default token will be selected automatically
+     */
+    symbol?: string;
+};
 export interface AppConfig {
     integratorId: string;
     slippage?: SlippageOption;
-    enableGetGasOnDestination?: boolean;
     /**
      * If set to true, will load initial tokens and chains from local storage
      */
@@ -23,8 +29,8 @@ export interface AppConfig {
      * If {@link loadPreviousStateFromLocalStorage} is set to true, this will be ignored
      */
     initialAssets?: {
-        from?: TokenConfig;
-        to?: TokenConfig;
+        from?: TokenConfig | NamedTokenConfig;
+        to?: TokenConfig | NamedTokenConfig;
     };
     /**
      * When chains are changed, this allows to choose the first token that will be selected

package/dist/core/types/cosmos.d.ts

@@ -0,0 +1,5 @@
+export type CosmosConnector = () => {
+    id: string;
+    name: string;
+    provider: any;
+};

package/dist/core/types/error.d.ts

@@ -13,13 +13,7 @@ export interface SquidRouteError {
     statusCode: number;
     type: string;
 }
-export interface SquidStatusError {
-    errorType?: string;
-}
 export type SquidRouteErrorType = "Unknown" | "UnknownError" | "SquidServiceError" | "BAD_REQUEST";
-export declare enum SquidStatusErrorType {
-    NotFoundError = "NotFoundError"
-}
 export declare class QrCodeGenerationError extends Error {
     constructor(message: string);
 }

package/dist/core/types/event.d.ts

@@ -36,6 +36,10 @@ export interface WidgetEventMap {
         toChainId?: string;
         fromTokenAddress?: string;
         toTokenAddress?: string;
+        fromNetworkName?: string;
+        toNetworkName?: string;
+        fromTokenSymbol?: string;
+        toTokenSymbol?: string;
     };
     swapTxSignatureRequested: {
         route: RouteResponse["route"];

package/dist/core/types/history.d.ts

@@ -1,8 +1,16 @@
-import { ChainType, StatusResponse } from "@0xsquid/squid-types";
+import { ChainType } from "@0xsquid/squid-types";
 import { OnRampTransactionStatusType } from "./onramps";
+import type { SwapStatusSummary } from "./status";
 import { SendTransactionStatus, SimplifiedRouteAction, TransactionStatus } from "./transaction";
-type SimplifiedStatusResponse = Pick<StatusResponse, "axelarTransactionUrl"> & {
-    toChain?: Pick<NonNullable<StatusResponse["toChain"]>, "transactionUrl"> | undefined;
+/**
+ * Explorer URLs of history items that were stored before the v3 status API.
+ * The v3 status document has no URLs.
+ */
+export type LegacyExplorerLinks = {
+    squidscan?: string;
+    axelarscan?: string;
+    chainflip?: string;
+    destination?: string;
 };
 export type SwapTransactionHistory = {
     fromChain: string;
@@ -20,10 +28,11 @@ export type SwapTransactionHistory = {
     timestamp: number;
     nonce?: number;
     routeType: string | undefined;
-    statusResponse?: SimplifiedStatusResponse;
+    statusSummary?: SwapStatusSummary;
+    legacyExplorerLinks?: LegacyExplorerLinks;
     sourceTxExplorerUrl?: string;
-    bridgeType?: string;
     actions?: SimplifiedRouteAction[];
+    depositTxVerificationSignature?: string;
 };
 export type SendTransactionHistory = {
     toAddress: string;
@@ -81,4 +90,3 @@ export type TxTypeToTransactionMap = {
     };
 };
 export type HistoryTransaction = TxTypeToTransactionMap[HistoryTxType];
-export {};

package/dist/core/types/index.d.ts

@@ -1,10 +1,11 @@
 export type { AppConfig } from "./config";
-export { SquidStatusErrorType, TransactionErrorType, type SquidRouteError, type SquidRouteErrorType, type SquidStatusError, } from "./error";
+export { TransactionErrorType, type SquidRouteError, type SquidRouteErrorType, } from "./error";
 export type { QrCodeData } from "./event";
 export * from "./history";
 export type * from "./onramps/";
+export type { KnownSwapStatusActionStatus, SwapStatus, SwapStatusAction, SwapStatusActionRole, SwapStatusActionStatus, SwapStatusActionType, SwapStatusBridgeType, SwapStatusChain, SwapStatusDocument, SwapStatusSummary, } from "./status";
 export type { SwapParams } from "./swap";
-export type { Chain, Token } from "./tokens";
-export { AxelarStatusResponseType, SendTransactionStatus, TransactionStatus, type PatchedRouteActionResponse, type TransactionParams, } from "./transaction";
+export type { Chain, Token, TrustLineAsset } from "./tokens";
+export { SendTransactionStatus, TransactionStatus, type PatchedRouteActionResponse, type TransactionParams, } from "./transaction";
 export type { AddressWithEns, BitcoinWallet, ConnectorID, CosmosWallet, EnsData, EnsSearchResult, FullAddressData, NetworkConfig, SolanaWallet, SupportedChain, Wallet, } from "./wallet";
 export { XamanXrplNetwork } from "./xrpl";

package/dist/core/types/solana.d.ts

@@ -1,2 +1,10 @@
 import type { StandardWalletAdapter } from "@solana/wallet-standard-wallet-adapter-base";
 export type SolanaConnector = StandardWalletAdapter;
+export declare const SOLANA_ON_CHAIN_ERROR_CODE = "SOLANA_ON_CHAIN_ERROR";
+export declare const SOLANA_BLOCKHASH_EXPIRED_CODE = "SOLANA_BLOCKHASH_EXPIRED";
+export type SolanaTransactionErrorCode = typeof SOLANA_ON_CHAIN_ERROR_CODE | typeof SOLANA_BLOCKHASH_EXPIRED_CODE;
+export declare class SolanaTransactionError extends Error {
+    readonly code: SolanaTransactionErrorCode;
+    readonly signature?: string;
+    constructor(code: SolanaTransactionErrorCode, message: string, signature?: string);
+}