@supanovaapp/sdk 0.2.12 → 0.2.13

package/dist/hooks/useAPI.d.ts

@@ -0,0 +1,142 @@
+import { UserResponseDto, UserBalanceResponseDto, DialogWithMessagesResponseDto, DialogListResponseDto, OffsetPaginatedDto, MessageResponseDto, PaginationParams, NetworkAddressAndPriceDto, TokenInfoWithPriceChangeDto, TokenInfo, TokenPriceHistoryParams, TokenPriceHistoryResponse, AccountTokensBalancesResponse, AlchemyNetwork, SupaPointsBalanceResponseDto, DailyLoginResponseDto, SupaPointsHistoryParams, TransactionQueryParams, PaymasterRequestDto, PaymasterResponseDto } from '../core/types';
+/**
+ * Return type for useAPI hook
+ * Provides organized access to all backend API methods
+ */
+export interface UseAPIReturn {
+    /** User management and profile methods */
+    user: {
+        /** Fetches current authenticated user profile */
+        getCurrent: () => Promise<UserResponseDto>;
+        /** Fetches all users (admin only) */
+        getAll: () => Promise<UserResponseDto[]>;
+        /** Fetches user by Privy ID */
+        getByPrivyId: (privyUserId: string) => Promise<UserResponseDto>;
+        /** Fetches user's smart wallet token balances */
+        getBalance: (force?: boolean) => Promise<UserBalanceResponseDto>;
+    };
+    /** AI dialog management methods */
+    dialogs: {
+        /** Creates a new AI dialog with initial message */
+        create: (text: string) => Promise<DialogWithMessagesResponseDto>;
+        /** Fetches all user dialogs with pagination */
+        findAll: (params?: PaginationParams) => Promise<OffsetPaginatedDto<DialogListResponseDto>>;
+        /** Fetches a specific dialog by ID */
+        findOne: (id: number) => Promise<DialogListResponseDto>;
+        /** Deletes a dialog and all its messages */
+        delete: (id: number) => Promise<void>;
+    };
+    /** AI message methods within dialogs */
+    messages: {
+        /** Creates a new message in a dialog */
+        create: (dialogId: number, text: string) => Promise<MessageResponseDto>;
+        /** Fetches all messages in a dialog with pagination */
+        findAll: (dialogId: number, params?: PaginationParams) => Promise<OffsetPaginatedDto<MessageResponseDto>>;
+        /** Fetches a specific message by ID */
+        findOne: (id: number) => Promise<MessageResponseDto>;
+    };
+    /** On-chain data and token price methods */
+    onchain: {
+        /** Fetches token prices by contract addresses */
+        getPricesByAddresses: (addresses: Array<{
+            network: AlchemyNetwork;
+            contractAddress: string;
+        }>) => Promise<NetworkAddressAndPriceDto[]>;
+        /** Fetches token prices by symbols (BTC, ETH, etc.) */
+        getTokenPrices: (symbols: string[]) => Promise<Record<string, number>>;
+        /** Fetches historical price data for a token */
+        getPriceHistory: (params: TokenPriceHistoryParams) => Promise<TokenPriceHistoryResponse>;
+        /** Fetches 24-hour price changes for tokens */
+        get24hrPriceChanges: (tokens: Array<{
+            network: AlchemyNetwork;
+            contractAddress: string;
+        }>) => Promise<TokenInfoWithPriceChangeDto[]>;
+        /** Fetches detailed token information */
+        getTokenInfo: (network: string, addresses: string | string[]) => Promise<Record<string, TokenInfo>>;
+        /** Fetches token balances for an account */
+        getAccountBalances: (network: string, account: string, force?: boolean) => Promise<AccountTokensBalancesResponse>;
+    };
+    /** Transaction history methods */
+    transactions: {
+        /** Fetches user transaction history */
+        get: (params?: TransactionQueryParams) => Promise<any>;
+        /** Forces reload of transaction history from blockchain */
+        forceLoad: (params?: TransactionQueryParams) => Promise<any>;
+    };
+    /** SupaPoints reward system methods */
+    supaPoints: {
+        /** Fetches current SupaPoints balance */
+        getBalance: () => Promise<SupaPointsBalanceResponseDto>;
+        /** Fetches SupaPoints transaction history */
+        getHistory: (params?: SupaPointsHistoryParams) => Promise<OffsetPaginatedDto<any>>;
+        /** Processes daily login bonus */
+        dailyLogin: () => Promise<DailyLoginResponseDto>;
+    };
+    /** Paymaster sponsorship methods */
+    paymaster: {
+        /** Checks if transaction qualifies for gas sponsorship */
+        checkSponsorship: (request: PaymasterRequestDto) => Promise<PaymasterResponseDto>;
+    };
+    /** Privy wallet methods */
+    privy: {
+        /** Fetches Privy embedded wallet balance */
+        getBalance: () => Promise<any>;
+    };
+}
+/**
+ * Hook for accessing Supa Backend API
+ * Provides organized, type-safe access to all backend endpoints
+ * All methods automatically include authentication token from Privy
+ *
+ * @returns Organized API methods grouped by functionality
+ *
+ * @example
+ * Basic usage
+ * ```tsx
+ * function UserBalance() {
+ *   const api = useAPI();
+ *   const [balance, setBalance] = useState(null);
+ *
+ *   useEffect(() => {
+ *     api.user.getBalance().then(setBalance);
+ *   }, []);
+ *
+ *   return <div>Balance: ${balance?.totalUsdBalance}</div>;
+ * }
+ * ```
+ *
+ * @example
+ * Creating an AI dialog
+ * ```tsx
+ * function CreateDialog() {
+ *   const api = useAPI();
+ *
+ *   const handleCreate = async () => {
+ *     const dialog = await api.dialogs.create('Hello AI!');
+ *     console.log('Dialog created:', dialog.id);
+ *     console.log('AI response:', dialog.messages[1].message);
+ *   };
+ *
+ *   return <button onClick={handleCreate}>Start Chat</button>;
+ * }
+ * ```
+ *
+ * @example
+ * Fetching crypto prices
+ * ```tsx
+ * function TokenPrices() {
+ *   const api = useAPI();
+ *
+ *   useEffect(() => {
+ *     api.onchain.getTokenPrices(['BTC', 'ETH', 'SOL'])
+ *       .then(prices => {
+ *         console.log('BTC:', prices.BTC);
+ *         console.log('ETH:', prices.ETH);
+ *       });
+ *   }, []);
+ *
+ *   return <div>Check console for prices</div>;
+ * }
+ * ```
+ */
+export declare const useAPI: () => UseAPIReturn;

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,45 @@
+import { User as PrivyUser } from '@privy-io/react-auth';
+/**
+ * Return type for useAuth hook
+ */
+export interface UseAuthReturn {
+    /** Opens Privy login modal */
+    login: () => void;
+    /** Logs out the current user */
+    logout: () => Promise<void>;
+    /** Whether user is authenticated */
+    authenticated: boolean;
+    /** Whether authentication is in progress */
+    loading: boolean;
+    /** Privy user object containing linked accounts and profile data */
+    user: PrivyUser | null;
+    /** Gets Privy JWT access token for authenticated API calls */
+    getAccessToken: () => Promise<string | null>;
+    /** Whether SDK is ready (not loading) */
+    ready: boolean;
+}
+/**
+ * Hook for managing user authentication via Privy
+ * Automatically configures API client with access token when user authenticates
+ *
+ * @returns Authentication methods and user state
+ *
+ * @example
+ * ```tsx
+ * function LoginButton() {
+ *   const { login, logout, authenticated, user } = useAuth();
+ *
+ *   if (!authenticated) {
+ *     return <button onClick={login}>Login</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {user?.email?.address}!</p>
+ *       <button onClick={logout}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare const useAuth: () => UseAuthReturn;

package/dist/hooks/useCanton.d.ts

@@ -0,0 +1,19 @@
+import { CantonContextValue } from '../providers/CantonProvider';
+export type { CantonContextValue as UseCantonReturn };
+/**
+ * Hook for Canton Network operations
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isRegistered, registerCanton, sendCantonCoin } = useCanton();
+ *
+ *   if (!isRegistered) {
+ *     return <button onClick={registerCanton}>Register</button>;
+ *   }
+ *
+ *   return <button onClick={() => sendCantonCoin(partyId, "10")}>Send</button>;
+ * }
+ * ```
+ */
+export declare function useCanton(): CantonContextValue;

package/dist/hooks/useConfirmModal.d.ts

@@ -0,0 +1,15 @@
+import { ConfirmModalOptions, SignMessageModalOptions, SignTransactionOptions, ModalResult } from '../providers/SupaProvider';
+export interface UseConfirmModalReturn {
+    /** Show a generic confirmation modal */
+    confirm: (options: ConfirmModalOptions) => Promise<ModalResult>;
+    /** Show a message signing confirmation modal */
+    signMessageConfirm: (options: SignMessageModalOptions) => Promise<ModalResult>;
+    /** Show a transaction signing confirmation modal */
+    signTransactionConfirm: (options: SignTransactionOptions) => Promise<ModalResult>;
+    /** Set loading state for current modal */
+    setModalLoading: (loading: boolean) => void;
+    /** Close current modal */
+    closeModal: () => void;
+}
+export declare function useConfirmModal(): UseConfirmModalReturn;
+export type { ConfirmModalOptions, SignMessageModalOptions, SignTransactionOptions, ModalResult };

package/dist/hooks/useSendTransaction.d.ts

@@ -0,0 +1,27 @@
+import { StellarWallet } from '../utils/stellar';
+import { CantonQueryCompletionResponseDto, CantonSubmitPreparedOptions } from '../services/cantonService';
+export interface SendTransactionOptions {
+    onSuccess?: (result: CantonQueryCompletionResponseDto) => void;
+    onRejection?: () => void;
+    onError?: (error: Error) => void;
+    skipModal?: boolean;
+    modalTitle?: string;
+    modalDescription?: string;
+    modalConfirmText?: string;
+    modalRejectText?: string;
+    /** Custom content to display in modal instead of transaction hash */
+    modalDisplayContent?: string;
+    /** Show technical transaction details (command, contracts, hash) as JSON. Default: false */
+    showTechnicalDetails?: boolean;
+    submitOptions?: CantonSubmitPreparedOptions;
+}
+export interface UseSendTransactionReturn {
+    /** Sign and send a Canton transaction with confirmation modal */
+    sendTransaction: (commands: unknown, disclosedContracts?: unknown, options?: SendTransactionOptions) => Promise<CantonQueryCompletionResponseDto | null>;
+    loading: boolean;
+    error: Error | null;
+    clearError: () => void;
+    stellarWallets: StellarWallet[];
+    stellarWallet: StellarWallet | null;
+}
+export declare function useSendTransaction(): UseSendTransactionReturn;

package/dist/hooks/useSignMessage.d.ts

@@ -0,0 +1,25 @@
+import { StellarWallet } from '../utils/stellar';
+export interface SignMessageOptions {
+    onSuccess?: (signature: string) => void;
+    onRejection?: () => void;
+    onError?: (error: Error) => void;
+    skipModal?: boolean;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+    /** Custom content to display in modal instead of message */
+    displayContent?: string;
+    /** Show technical details (address, chainType, hash) as JSON. Default: false */
+    showTechnicalDetails?: boolean;
+}
+export interface UseSignMessageReturn {
+    /** Sign a text message with confirmation modal */
+    signMessage: (message: string, options?: SignMessageOptions) => Promise<string | null>;
+    loading: boolean;
+    error: Error | null;
+    clearError: () => void;
+    stellarWallets: StellarWallet[];
+    stellarWallet: StellarWallet | null;
+}
+export declare function useSignMessage(): UseSignMessageReturn;

package/dist/hooks/useSignRawHashWithModal.d.ts

@@ -0,0 +1,22 @@
+import { useSignRawHash } from '@privy-io/react-auth/extended-chains';
+export interface SignRawHashModalOptions {
+    skipModal?: boolean;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+    infoText?: string;
+    /** Custom content to display instead of auto-generated JSON */
+    displayHash?: string;
+    /** Show technical details (address, chainType, hash) as JSON. Default: false */
+    showTechnicalDetails?: boolean;
+}
+type SignRawHashParams = Parameters<ReturnType<typeof useSignRawHash>['signRawHash']>[0];
+export interface UseSignRawHashWithModalReturn {
+    /** Sign a raw hash with confirmation modal */
+    signRawHashWithModal: (params: SignRawHashParams, modalOptions?: SignRawHashModalOptions) => Promise<{
+        signature: string;
+    } | null>;
+}
+export declare function useSignRawHashWithModal(): UseSignRawHashWithModalReturn;
+export {};

package/dist/hooks/useSmartWallets.d.ts

@@ -0,0 +1,16 @@
+import { useSmartWallets as usePrivySmartWallets } from '@privy-io/react-auth/smart-wallets';
+export interface UseSmartWalletsReturn {
+    /** Client for interacting with smart wallets */
+    client: ReturnType<typeof usePrivySmartWallets>['client'];
+    /** Get client for specific chain */
+    getClientForChain: ReturnType<typeof usePrivySmartWallets>['getClientForChain'];
+    /** Get user's smart wallet address */
+    address: string | undefined;
+    /** Whether smart wallets are ready to use */
+    ready: boolean;
+}
+/**
+ * Hook for using Privy Smart Wallets
+ * Must be used within SmartWalletsProvider (automatically enabled in SupaProvider when smartWallets.enabled = true)
+ */
+export declare function useSmartWallets(): UseSmartWalletsReturn;

package/dist/hooks/useStellarWallet.d.ts

@@ -0,0 +1,6 @@
+import { StellarWallet } from '../utils/stellar';
+export interface UseStellarWalletReturn {
+    stellarWallets: StellarWallet[];
+    stellarWallet: StellarWallet | null;
+}
+export declare function useStellarWallet(): UseStellarWalletReturn;

package/dist/hooks/useSupa.d.ts

@@ -0,0 +1,61 @@
+import { UseAuthReturn } from './useAuth';
+import { UseCantonReturn } from './useCanton';
+import { UseAPIReturn } from './useAPI';
+/**
+ * Return type for useSupa hook
+ */
+export interface UseSupaReturn {
+    /** Authentication methods and user state */
+    auth: UseAuthReturn;
+    /** Canton Network operations and wallet management */
+    canton: UseCantonReturn;
+    /** Backend API methods for data access */
+    api: UseAPIReturn;
+    /** Automated onboarding flow (login → create wallet → register Canton) */
+    onboard: () => Promise<void>;
+}
+/**
+ * Main hook for accessing all Supa SDK features
+ * Combines authentication, Canton Network, and API functionality
+ *
+ * Note: Canton state (isRegistered, cantonUser, etc.) is shared across
+ * all components via CantonProvider. No duplicate registration will occur.
+ *
+ * @returns Combined SDK functionality with convenience methods
+ *
+ * @example
+ * Basic usage
+ * ```tsx
+ * function Dashboard() {
+ *   const { auth, canton, api } = useSupa();
+ *
+ *   if (!auth.authenticated) {
+ *     return <button onClick={auth.login}>Login</button>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>User: {auth.user?.email?.address}</p>
+ *       <button onClick={() => canton.registerCanton()}>
+ *         Register Canton
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Using automated onboarding
+ * ```tsx
+ * function OnboardButton() {
+ *   const { onboard, canton } = useSupa();
+ *
+ *   return (
+ *     <button onClick={onboard}>
+ *       {canton.isRegistered ? 'Already registered' : 'Get Started'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare const useSupa: () => UseSupaReturn;

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Supa SDK
+ *
+ * React SDK for seamless integration with Supa Backend API and Privy.io authentication,
+ * featuring full Canton Network support with Ed25519 signing via Stellar wallets.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * Basic setup
+ * ```tsx
+ * import { SupaProvider, useAuth, useCanton } from '@supa/sdk';
+ *
+ * function App() {
+ *   return (
+ *     <SupaProvider config={{ privyAppId: 'your_app_id' }}>
+ *       <Dashboard />
+ *     </SupaProvider>
+ *   );
+ * }
+ *
+ * function Dashboard() {
+ *   const { login, authenticated } = useAuth();
+ *   const { registerCanton, isRegistered } = useCanton();
+ *
+ *   if (!authenticated) {
+ *     return <button onClick={login}>Login</button>;
+ *   }
+ *
+ *   if (!isRegistered) {
+ *     return <button onClick={registerCanton}>Register Canton</button>;
+ *   }
+ *
+ *   return <div>Ready to use Canton Network!</div>;
+ * }
+ * ```
+ *
+ * @see {@link https://github.com/your-repo/supa-sdk | GitHub Repository}
+ * @see {@link https://docs.privy.io | Privy Documentation}
+ * @see {@link https://canton.network | Canton Network}
+ */
+/**
+ * Main provider component that wraps your application
+ * Includes built-in confirmation modals for signing operations
+ * @see {@link SupaProvider}
+ */
+export { SupaProvider, useSupaContext } from './providers/SupaProvider';
+export type { SupaConfig, SupaContextValue, SupaProviderProps, ConfirmModalOptions, SignMessageModalOptions, SignTransactionOptions as SignTransactionModalOptions, ModalResult, } from './providers/SupaProvider';
+/**
+ * Canton Provider for shared state (automatically included in SupaProvider)
+ * @see {@link CantonProvider}
+ */
+export { CantonProvider, useCantonContext } from './providers/CantonProvider';
+export type { CantonContextValue, CantonProviderProps, CantonSendCoinOptions } from './providers/CantonProvider';
+/**
+ * Primary hook combining all SDK functionality
+ * @see {@link useSupa}
+ */
+export { useSupa } from './hooks/useSupa';
+export type { UseSupaReturn } from './hooks/useSupa';
+export { useSupa as useWalletino } from './hooks/useSupa';
+export type { UseSupaReturn as UseWalletinoReturn } from './hooks/useSupa';
+/**
+ * Authentication hook for Privy integration
+ * @see {@link useAuth}
+ */
+export { useAuth } from './hooks/useAuth';
+export type { UseAuthReturn } from './hooks/useAuth';
+/**
+ * Canton Network operations hook
+ * @see {@link useCanton}
+ */
+export { useCanton } from './hooks/useCanton';
+export type { UseCantonReturn } from './hooks/useCanton';
+/**
+ * Sign message hook with confirmation modal
+ * @see {@link useSignMessage}
+ */
+export { useSignMessage } from './hooks/useSignMessage';
+export type { UseSignMessageReturn, SignMessageOptions } from './hooks/useSignMessage';
+/**
+ * Send transaction hook with confirmation modal
+ * @see {@link useSendTransaction}
+ */
+export { useSendTransaction } from './hooks/useSendTransaction';
+export type { UseSendTransactionReturn, SendTransactionOptions } from './hooks/useSendTransaction';
+/**
+ * Sign raw hash with automatic confirmation modal
+ * @see {@link useSignRawHashWithModal}
+ */
+export { useSignRawHashWithModal } from './hooks/useSignRawHashWithModal';
+export type { UseSignRawHashWithModalReturn, SignRawHashModalOptions } from './hooks/useSignRawHashWithModal';
+/**
+ * Confirmation modal hook
+ * @see {@link useConfirmModal}
+ */
+export { useConfirmModal } from './hooks/useConfirmModal';
+export type { UseConfirmModalReturn } from './hooks/useConfirmModal';
+/**
+ * Stellar wallet hook
+ * @see {@link useStellarWallet}
+ */
+export { useStellarWallet } from './hooks/useStellarWallet';
+export type { UseStellarWalletReturn } from './hooks/useStellarWallet';
+/**
+ * Smart Wallets hook (EVM)
+ * @see {@link useSmartWallets}
+ */
+export { useSmartWallets } from './hooks/useSmartWallets';
+export type { UseSmartWalletsReturn } from './hooks/useSmartWallets';
+/**
+ * Confirmation modal components (for custom usage)
+ * @see {@link ConfirmationModal}, {@link SignMessageModal}, {@link SignTransactionModal}
+ */
+export { ConfirmationModal, SignMessageModal, SignTransactionModal } from './components/ConfirmationModal';
+export type { ConfirmationModalProps, SignMessageModalProps, SignTransactionModalProps } from './components/ConfirmationModal';
+/**
+ * All DTO types generated from Swagger specification
+ * Includes types for User, Dialog, Message, Canton, Token, etc.
+ */
+export * from './core/types';
+/**
+ * Format conversion utilities (hex ↔ base64)
+ * Required for Canton Network integration
+ * @see {@link hexToBase64}, {@link base64ToHex}, {@link privyPublicKeyToCantonBase64}
+ */
+export * from './utils/converters';
+/**
+ * Stellar wallet utilities for Canton Network
+ * @see {@link getStellarWallets}, {@link getPublicKeyBase64}, {@link isStellarWallet}
+ */
+export * from './utils/stellar';
+/**
+ * Canton Network service for direct API access (advanced usage)
+ * @see {@link CantonService}
+ */
+export { CantonService, getCantonService } from './services/cantonService';
+export type { CantonRegisterParams, CantonTapParams, CantonSubmitPreparedOptions } from './services/cantonService';
+/**
+ * Backend API service for direct access (advanced usage)
+ * @see {@link ApiService}
+ */
+export { ApiService, getApiService } from './services/apiService';
+/**
+ * HTTP client for custom API calls (advanced usage)
+ * @see {@link ApiClient}, {@link createApiClient}
+ */
+export { ApiClient, createApiClient, getApiClient } from './core/client';
+export type { ClientConfig } from './core/client';

package/dist/providers/CantonProvider.d.ts

@@ -0,0 +1,64 @@
+import { ReactNode } from 'react';
+import { StellarWallet } from '../utils/stellar';
+import { CantonService, CantonSubmitPreparedOptions } from '../services/cantonService';
+import { CantonMeResponseDto, CantonActiveContractsResponseDto, CantonQueryCompletionResponseDto, CantonWalletBalancesResponseDto, CantonIncomingTransferDto, CantonTransactionDto, CantonTransactionsParams, CantonPriceInterval, CantonPriceCandleDto } from '../core/types';
+export interface CantonSendCoinOptions extends CantonSubmitPreparedOptions {
+    /** Skip confirmation modal. Default: false */
+    skipModal?: boolean;
+}
+export interface CantonContextValue {
+    /** First Stellar wallet (primary) */
+    stellarWallet: StellarWallet | null;
+    /** All Stellar wallets */
+    stellarWallets: StellarWallet[];
+    /** Create new Stellar wallet */
+    createStellarWallet: () => Promise<StellarWallet | null>;
+    /** Register Canton wallet on backend */
+    registerCanton: (inviteCode?: string) => Promise<void>;
+    /** Whether Canton wallet is registered */
+    isRegistered: boolean;
+    /** Canton user info (partyId, email, transferPreapprovalSet) */
+    cantonUser: CantonMeResponseDto | null;
+    /** Get Canton user info */
+    getMe: () => Promise<CantonMeResponseDto>;
+    /** Get active contracts with optional filtering */
+    getActiveContracts: (templateIds?: string[]) => Promise<CantonActiveContractsResponseDto>;
+    /** Canton wallet balances */
+    cantonBalances: CantonWalletBalancesResponseDto | null;
+    /** Get Canton wallet balances */
+    getBalances: () => Promise<CantonWalletBalancesResponseDto>;
+    /** Tap devnet faucet */
+    tapDevnet: (amount: string, options?: CantonSubmitPreparedOptions) => Promise<CantonQueryCompletionResponseDto>;
+    /** Sign hash with Stellar wallet */
+    signHash: (hashBase64: string) => Promise<string>;
+    /** Sign text message */
+    signMessage: (message: string) => Promise<string>;
+    /** Prepare and submit transaction with polling for completion */
+    sendTransaction: (commands: unknown, disclosedContracts?: unknown, options?: CantonSubmitPreparedOptions) => Promise<CantonQueryCompletionResponseDto>;
+    /** Send Canton Coin (Amulet) to another party */
+    sendCantonCoin: (receiverPartyId: string, amount: string, memo?: string, options?: CantonSendCoinOptions) => Promise<CantonQueryCompletionResponseDto>;
+    /** Setup transfer preapproval (internal, called automatically) */
+    setupTransferPreapproval: () => Promise<void>;
+    /** Get pending incoming transfers */
+    getPendingIncomingTransfers: () => Promise<CantonIncomingTransferDto[]>;
+    /** Respond to incoming transfer (accept or reject) */
+    respondToIncomingTransfer: (contractId: string, accept: boolean, options?: CantonSubmitPreparedOptions) => Promise<CantonQueryCompletionResponseDto>;
+    /** Get Canton transactions history with pagination */
+    getTransactions: (params?: CantonTransactionsParams) => Promise<CantonTransactionDto[]>;
+    /** Get Canton price history (candles from Bybit) */
+    getPriceHistory: (interval: CantonPriceInterval) => Promise<CantonPriceCandleDto[]>;
+    /** Loading state */
+    loading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Clear error */
+    clearError: () => void;
+}
+export interface CantonProviderProps {
+    cantonService: CantonService;
+    children: ReactNode;
+    /** Enable automatic onboarding (create wallet + register Canton on login). Default: true */
+    autoOnboarding?: boolean;
+}
+export declare function CantonProvider({ cantonService, children, autoOnboarding }: CantonProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useCantonContext(): CantonContextValue;