@0xsquid/react-hooks 8.9.1-beta.0 → 8.10.0

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

@@ -0,0 +1,28 @@
+import type { CantonAccount, CantonConnectResult, CantonConnector, CantonConnectorEvent, CantonConnectorEventHandler, CantonLedgerApiParams, CantonPrepareExecuteAndWaitResult, CantonPrepareExecuteParams } 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 CantonConnector {
+    readonly providerId: string;
+    readonly name: string;
+    readonly target: string | undefined;
+    private readonly client;
+    private readonly listeners;
+    private _accounts;
+    constructor(provider: AnnouncedCantonProvider, win?: Window);
+    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[]>;
+    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/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/errors/index.d.ts

@@ -10,7 +10,4 @@ export declare class BitcoinConnectorTransactionFailedError extends BitcoinConne
 export declare class BitcoinConnectorInvalidAccountError extends BitcoinConnectorError {
     constructor();
 }
-export declare class BitcoinConnectorFeatureNotSupportedError extends BitcoinConnectorError {
-    constructor(providerName: string, feature: string);
-}
 export {};

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

@@ -1,4 +1,3 @@
 export { KeplrConnector } from "./keplr";
 export { PhantomConnector } from "./phantom";
-export { BitcoinStandardConnector } from "./standard";
 export { UnisatConnector } from "./unisat";

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

@@ -1,11 +1,27 @@
-import { BitcoinStandardConnector } from "./standard";
-/**
- * Phantom Bitcoin connector via the Bitcoin Wallet Standard.
- *
- * Phantom deprecated the injected `window.phantom.bitcoin` provider in favour of
- * the Wallet Standard; this resolves Phantom from the registry by name and signs
- * through the standard Bitcoin features. See {@link BitcoinStandardConnector}.
- */
-export declare class PhantomConnector extends BitcoinStandardConnector {
-    constructor();
+import { BitcoinConnector } from "../../../../core/types/bitcoin";
+export interface PhantomBitcoinAccount {
+    address: string;
+    publicKey: string;
+    addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+    purpose: "payment" | "ordinals";
 }
+interface PhantomProvider {
+    requestAccounts: () => Promise<PhantomBitcoinAccount[]>;
+    signPSBT: (psbt: Uint8Array, options: {
+        inputsToSign: {
+            address: string;
+            signingIndexes: number[];
+        }[];
+    }) => Promise<Uint8Array>;
+}
+export declare class PhantomConnector implements BitcoinConnector {
+    get getProvider(): PhantomProvider;
+    requestAccount(): Promise<{
+        address: string;
+    }>;
+    sendBTC(to: string, amount: number): Promise<{
+        txHash: string;
+    }>;
+    private signPsbt;
+}
+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";
@@ -80,6 +82,7 @@ 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 chainTypeToDefaultChainIdMap: Record<ChainType, string>;
 export declare const chainTypeToNativeTokenAddressMap: Record<ChainType, string>;

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/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/types/canton.d.ts

@@ -0,0 +1,58 @@
+import type { CantonClient } from "@sigilry/dapp";
+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 type CantonConnectorEvent = keyof CantonConnectorEventMap;
+export type CantonConnectorEventHandler<E extends CantonConnectorEvent> = (...args: CantonConnectorEventMap[E]) => void;
+export interface CantonConnectResult {
+    address: string;
+    accounts: CantonAccount[];
+}
+export interface CantonConnector {
+    readonly providerId: string;
+    readonly name: string;
+    readonly target: string | undefined;
+    connect(): Promise<CantonConnectResult>;
+    autoConnect(): Promise<CantonConnectResult>;
+    disconnect(): Promise<void>;
+    ledgerApi<T = unknown>(params: CantonLedgerApiParams): Promise<T>;
+    prepareExecuteAndWait(params: CantonPrepareExecuteParams): Promise<CantonPrepareExecuteAndWaitResult>;
+    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;
+}

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

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

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

@@ -1,5 +1,7 @@
 import type { ChainType } from "@0xsquid/squid-types";
 import { BitcoinConnector } from "./bitcoin";
+import { CantonConnector } from "./canton";
+import { CosmosConnector } from "./cosmos";
 import { EvmConnector } from "./evm";
 import { SolanaConnector } from "./solana";
 import { StellarConnector } from "./stellar";
@@ -30,12 +32,7 @@ export declare enum WindowWalletFlag {
 export type ConnectorID = "metamask" | "coinbase" | "walletConnect" | "keplr" | "cosmostation" | "leap" | "ctrl" | "bitget" | "rabby" | "okx" | "injected" | "trustwallet" | "exodus" | "rainbow" | "phantom" | "backpack" | "unisat" | "xrpl-metamask-snap" | "crossmark" | "xaman-xapp" | "xaman-qr" | "joey" | "girin" | "bifrost" | "brave" | "tokenpocket" | "nightly" | "cryptodotcom" | "freighter" | "xBull" | "lobstr" | "albedo" | "hanaWallet" | "hotWallet";
 export type EvmWallet = Wallet & {
     type: ChainType.EVM;
-    connector: EvmConnector;
-};
-type CosmosConnector = () => {
-    id: string;
-    name: string;
-    provider: any;
+    connector: ConnectorByChainType[ChainType.EVM];
 };
 export type CosmosWallet = Wallet & {
     type: ChainType.COSMOS;
@@ -61,6 +58,10 @@ export type StellarWallet = Wallet & {
     type: ChainType.STELLAR;
     connector: ConnectorByChainType[ChainType.STELLAR];
 };
+export type CantonWallet = Wallet & {
+    type: ChainType.CANTON;
+    connector: ConnectorByChainType[ChainType.CANTON];
+};
 export type SupportedChain = {
     chainType: ChainType;
     chains?: string[];
@@ -71,6 +72,11 @@ export type NetworkConfig = {
         connector: ConnectorByChainType[T];
     };
 }[ChainType];
+export type WalletLinks = {
+    website?: string;
+    chrome?: string;
+    firefox?: string;
+};
 export type Wallet = {
     name: string;
     connectorId: ConnectorID;
@@ -82,7 +88,7 @@ export type Wallet = {
     isInstalled?: () => boolean;
     skipInstallCheck?: boolean;
     rdns?: string;
-    url?: string;
+    links?: WalletLinks;
 } & ({
     isMultiChain: true;
     supportedNetworks: NetworkConfig[];
@@ -137,6 +143,7 @@ export interface ChainTypeToWalletState {
     [ChainType.SUI]: BaseWalletState<SuiWallet> & SuiAccount;
     [ChainType.XRPL]: BaseWalletState<XrplWallet>;
     [ChainType.STELLAR]: BaseWalletState<StellarWallet>;
+    [ChainType.CANTON]: BaseWalletState<CantonWallet>;
 }
 interface ConnectorByChainType extends Record<ChainType, unknown> {
     [ChainType.EVM]: EvmConnector;
@@ -146,5 +153,6 @@ interface ConnectorByChainType extends Record<ChainType, unknown> {
     [ChainType.SUI]: SuiConnector;
     [ChainType.XRPL]: XrplConnector;
     [ChainType.STELLAR]: StellarConnector;
+    [ChainType.CANTON]: CantonConnector;
 }
 export {};

package/dist/core/wallets.d.ts

@@ -1,6 +1,11 @@
 import { ConnectorID } from "./types";
 import { Wallet, XrplWallet } from "./types/wallet";
 export declare const walletIconBaseUrl = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/wallets";
+/**
+ * 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.
+ */
+export declare const accessProperty: (object: Record<string, any>, path: string) => any;
 export declare const xrplWallets: XrplWallet[];
 export declare const multiChainWallets: Wallet[];
 export declare const singleChainWallets: Wallet[];

package/dist/hooks/canton/useCanton.d.ts

@@ -0,0 +1,2 @@
+import { ICantonContextData } from "../../core/providers/CantonProvider";
+export declare function useCanton(): ICantonContextData;

package/dist/hooks/canton/useCantonWallets.d.ts

@@ -0,0 +1,8 @@
+import { CantonWallet } from "../../core/types/wallet";
+/**
+ * Discovers Canton browser-extension wallets via the CIP-103 announce protocol
+ * (on mount and on window focus) and maps each to a {@link CantonWallet}.
+ */
+export declare function useCantonWallets(): {
+    wallets: CantonWallet[];
+};

package/dist/hooks/chains/useSquidChains.d.ts

@@ -12,6 +12,7 @@ export declare const useSquidChains: (direction?: SwapDirection) => {
     suiChains: ChainData[];
     xrplChains: ChainData[];
     stellarChains: ChainData[];
+    cantonChains: ChainData[];
     getChainType: (chainId?: string) => ChainType | undefined;
     findChain: (chainId: string | undefined) => ChainData | undefined;
 };

package/dist/hooks/index.d.ts

@@ -37,6 +37,7 @@ export { useSendTransaction } from "./transaction/send/useSendTransaction";
 export { useSendTransactionGas } from "./transaction/send/useSendTransactionGas";
 export { useAllTransactionsStatus } from "./transaction/useAllTransactionsStatus";
 export { useApproval } from "./transaction/useApproval";
+export { useDepositTransactionStatus } from "./transaction/useDepositTransactionStatus";
 export { useEstimate } from "./transaction/useEstimate";
 export { useEstimatePriceImpact } from "./transaction/useEstimatePriceImpact";
 export { useExecuteTransaction } from "./transaction/useExecuteTransaction";

package/dist/hooks/store/useDepositAddressStore.d.ts

@@ -1,9 +1,22 @@
-import { DepositAddressResponse } from "@0xsquid/squid-types";
+export interface DepositData {
+    depositAddress: string;
+    amount: string;
+    /**
+     * Identifier sent to backend to check for deposit status
+     */
+    statusTrackingId: string;
+    /**
+     * Memo to be sent with the deposit transaction on-chain
+     * Used by backend to track and index deposits
+     */
+    memo?: string;
+}
+export type PaymentMethod = "connectedWallet" | "depositAddress";
 interface DepositAddressStore {
-    deposit: DepositAddressResponse | null;
-    isEnabled: boolean;
-    setDeposit(data: DepositAddressResponse | null): void;
-    toggleDepositFlow(enabled: boolean): void;
+    deposit: DepositData | null;
+    selectedPaymentMethod: PaymentMethod;
+    setDeposit(data: DepositData | null): void;
+    setPaymentMethod(method: PaymentMethod): void;
 }
 export declare const useDepositAddressStore: import("zustand").UseBoundStore<import("zustand").StoreApi<DepositAddressStore>>;
 export {};

package/dist/hooks/swap/useDepositAddress.d.ts

@@ -1,16 +1,15 @@
 import { RouteResponse } from "@0xsquid/squid-types";
+import { PaymentMethod } from "../store/useDepositAddressStore";
 export declare function useDepositAddress(squidRoute?: RouteResponse["route"]): {
-    isEnabled: boolean;
+    paymentMethod: PaymentMethod;
+    isDepositAddressActive: boolean;
     isAvailableAsPaymentMethod: boolean;
     swapWillGenerateDepositAddress: boolean;
-    enable: () => void;
-    disable: () => void;
-    getRouteWithDeposit: import("@tanstack/react-query").UseMutationResult<{
-        depositAddress: import("@0xsquid/squid-types").ChainflipDepositAddressResponse;
-    }, unknown, {
+    setPaymentMethod: (method: PaymentMethod) => void;
+    getRouteWithDeposit: import("@tanstack/react-query").UseMutationResult<void, unknown, {
         route: RouteResponse["route"];
     }, unknown>;
     depositAddress: string | undefined;
     closeDepositChannel: () => void;
-    depositData: import("@0xsquid/squid-types").ChainflipDepositAddressResponse | null;
+    depositData: import("../store/useDepositAddressStore").DepositData | null;
 };

package/dist/hooks/tokens/useBalance.d.ts

@@ -17,4 +17,5 @@ export declare const useBitcoinBalance: ({ userAddress, chain, }: UseBalanceOpti
 export declare const useSuiBalance: ({ chain, token, userAddress, enabled, refreshIntervalMs, }: UseBalanceOptions) => UseBalanceResult;
 export declare const useXrplBalance: ({ userAddress, chain, enabled, token, refreshIntervalMs, }: UseBalanceOptions) => UseBalanceResult;
 export declare const useStellarBalance: ({ userAddress, chain, enabled, token, refreshIntervalMs, }: UseBalanceOptions) => UseBalanceResult;
+export declare const useCantonBalance: ({ chain, token, userAddress, enabled, refreshIntervalMs, }: UseBalanceOptions) => UseBalanceResult;
 export {};

package/dist/hooks/tokens/useNativeBalance.d.ts

@@ -18,6 +18,7 @@ export declare const useSolanaNativeBalance: ({ chain, address, }: UseNativeBala
 export declare const useSuiNativeBalance: ({ address, chain, }: UseNativeBalanceOptions) => UseNativeBalanceResult;
 export declare const useXrplNativeBalance: ({ address, chain, }: UseNativeBalanceOptions) => UseNativeBalanceResult;
 export declare const useStellarNativeBalance: ({ address, chain, }: UseNativeBalanceOptions) => UseNativeBalanceResult;
+export declare const useCantonNativeBalance: ({ address, chain, }: UseNativeBalanceOptions) => UseNativeBalanceResult;
 export declare const useNativeBalance: (chain?: ChainData) => {
     nativeBalance: Balance | undefined;
     nativeBalanceFormatted: string | undefined;

package/dist/hooks/tokens/useSquidTokens.d.ts

@@ -13,4 +13,5 @@ export declare const useSquidTokens: (direction?: SwapDirection) => {
     suiTokens: Token[];
     xrplTokens: Token[];
     stellarTokens: Token[];
+    cantonTokens: Token[];
 };

package/dist/hooks/transaction/useDepositTransactionStatus.d.ts

@@ -0,0 +1,20 @@
+import { RouteResponse } from "@0xsquid/squid-types";
+import { SwapTransactionForStatus } from "../../core/types/transaction";
+interface UseDepositTransactionStatusParams {
+    transaction?: SwapTransactionForStatus;
+    route?: RouteResponse["route"];
+    retry?: number;
+    refetchOnWindowFocus?: "always" | boolean;
+    enabled?: boolean;
+    onReceived?: () => void;
+}
+/**
+ * Tracks a deposit address intent before it becomes a persisted swap history item.
+ *
+ * Once the source deposit is received, it registers the transaction in the transaction
+ * and history stores, then signals the view via `onReceived` to navigate.
+ */
+export declare const useDepositTransactionStatus: ({ transaction, route, retry, refetchOnWindowFocus, enabled, onReceived, }: UseDepositTransactionStatusParams) => {
+    transactionStatusQuery: import("@tanstack/react-query").UseQueryResult<import("@0xsquid/squid-types").StatusResponse, Error>;
+};
+export {};

package/dist/hooks/transaction/useSwapStatusQuery.d.ts

@@ -0,0 +1,29 @@
+import { StatusResponse } from "@0xsquid/squid-types";
+import { SwapTransactionForStatus, TransactionStatus } from "../../core/types/transaction";
+interface UseSwapStatusQueryParams {
+    transaction?: SwapTransactionForStatus;
+    retry?: number;
+    refetchOnWindowFocus?: "always" | boolean;
+    enabled?: boolean;
+    /**
+     * Fires on every successful status response, with the raw status string.
+     * Use for non-terminal transitions (e.g. a deposit being received).
+     */
+    onStatus?: (params: {
+        status: string;
+        statusResponse: StatusResponse;
+    }) => void;
+    /**
+     * Fires on terminal status transitions
+     */
+    onEndStatus?: (params: {
+        status: TransactionStatus;
+        statusResponse: StatusResponse;
+    }) => void;
+    onNotFound?: () => void;
+    onError?: () => void;
+}
+export declare const useSwapStatusQuery: ({ transaction, retry, refetchOnWindowFocus, enabled, onStatus, onEndStatus, onNotFound, onError, }: UseSwapStatusQueryParams) => {
+    transactionStatusQuery: import("@tanstack/react-query").UseQueryResult<StatusResponse, Error>;
+};
+export {};