@supanovaapp/sdk 0.2.0 → 0.2.3

package/dist/index.d.ts

@@ -0,0 +1,1459 @@
+/**
+ * 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}
+ */
+
+import { AxiosRequestConfig } from 'axios';
+import { JSX } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { User } from '@privy-io/react-auth';
+import { useSignRawHash } from '@privy-io/react-auth/extended-chains';
+import { useSmartWallets as useSmartWallets_2 } from '@privy-io/react-auth/smart-wallets';
+
+export declare interface AccountTokenBalance {
+    contractAddress: string;
+    tokenBalance: string;
+    error?: any | null;
+}
+
+export declare interface AccountTokensBalancesResponse {
+    address: string;
+    tokenBalances: AccountTokenBalance[];
+}
+
+export declare type AlchemyNetwork = 'eth-mainnet' | 'arb-mainnet' | 'opt-mainnet' | 'polygon-mainnet';
+
+export declare class ApiClient {
+    private client;
+    private getAccessToken?;
+    private nodeIdentifier;
+    constructor(config?: ClientConfig);
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    setAccessTokenGetter(getter: () => Promise<string | null>): void;
+    getBaseURL(): string;
+}
+
+export declare interface ApiError {
+    statusCode: number;
+    message: string;
+    error?: string;
+}
+
+export declare interface ApiResponse<T = any> {
+    data?: T;
+    error?: ApiError;
+}
+
+export declare class ApiService {
+    private client;
+    constructor(client: ApiClient);
+    /**
+     * Get current user information
+     * GET /user/me
+     */
+    getCurrentUser(): Promise<UserResponseDto>;
+    /**
+     * Get all users
+     * GET /user/all
+     */
+    getAllUsers(): Promise<UserResponseDto[]>;
+    /**
+     * Get user by Privy user ID
+     * GET /user/{privyUserId}
+     */
+    getUserByPrivyId(privyUserId: string): Promise<UserResponseDto>;
+    /**
+     * Get current user's smart wallet token balances
+     * GET /user/smart_wallet_balances
+     */
+    getSmartWalletBalances(force?: boolean): Promise<UserBalanceResponseDto>;
+    /**
+     * Create new dialog
+     * POST /dialogs
+     */
+    createDialog(text: string): Promise<DialogWithMessagesResponseDto>;
+    /**
+     * Get all user dialogs
+     * GET /dialogs
+     */
+    getAllDialogs(params?: PaginationParams): Promise<OffsetPaginatedDto<DialogListResponseDto>>;
+    /**
+     * Get specific dialog
+     * GET /dialogs/{id}
+     */
+    getDialog(id: number): Promise<DialogListResponseDto>;
+    /**
+     * Delete dialog
+     * DELETE /dialogs/{id}
+     */
+    deleteDialog(id: number): Promise<void>;
+    /**
+     * Create new message in dialog
+     * POST /dialogs/{dialogId}/messages
+     */
+    createMessage(dialogId: number, text: string): Promise<MessageResponseDto>;
+    /**
+     * Get all messages in dialog
+     * GET /dialogs/{dialogId}/messages
+     */
+    getDialogMessages(dialogId: number, params?: PaginationParams): Promise<OffsetPaginatedDto<MessageResponseDto>>;
+    /**
+     * Get specific message
+     * GET /messages/{id}
+     */
+    getMessage(id: number): Promise<MessageResponseDto>;
+    /**
+     * Get token prices by contract addresses
+     * POST /onchain/tokens_prices_by_addresses
+     */
+    getTokenPricesByAddresses(addresses: Array<{
+        network: AlchemyNetwork;
+        contractAddress: string;
+    }>): Promise<NetworkAddressAndPriceDto[]>;
+    /**
+     * Get token prices by symbols
+     * GET /onchain/tokens_prices
+     * @param symbols Array of token symbols (e.g., ['BTC', 'ETH', 'USDT'])
+     */
+    getTokenPrices(symbols: string[]): Promise<Record<string, number>>;
+    /**
+     * Get token price history
+     * GET /onchain/token_price_history
+     */
+    getTokenPriceHistory(params: TokenPriceHistoryParams): Promise<TokenPriceHistoryResponse>;
+    /**
+     * Get 24hr price changes for tokens
+     * POST /onchain/tokens_24hr_changes
+     */
+    getTokens24hrPriceChanges(tokens: Array<{
+        network: AlchemyNetwork;
+        contractAddress: string;
+    }>): Promise<TokenInfoWithPriceChangeDto[]>;
+    /**
+     * Get token info by address(es)
+     * GET /onchain/token_info/{network}
+     * @param network Blockchain network
+     * @param addresses Single address or array of addresses
+     */
+    getTokenInfo(network: string, addresses: string | string[]): Promise<Record<string, TokenInfo>>;
+    /**
+     * Get account token balances
+     * GET /onchain/account_tokens_balances/{network}
+     */
+    getAccountTokenBalances(network: string, account: string, force?: boolean): Promise<AccountTokensBalancesResponse>;
+    /**
+     * Get user transactions
+     * GET /transactions
+     */
+    getTransactions(params?: TransactionQueryParams): Promise<any>;
+    /**
+     * Force load user transactions
+     * POST /transactions/transactions_force
+     */
+    forceLoadTransactions(params?: TransactionQueryParams): Promise<any>;
+    /**
+     * Get SupaPoints balance
+     * GET /supa_points/balance
+     */
+    getSupaPointsBalance(): Promise<SupaPointsBalanceResponseDto>;
+    /**
+     * Get SupaPoints history
+     * GET /supa_points/history
+     */
+    getSupaPointsHistory(params?: SupaPointsHistoryParams): Promise<OffsetPaginatedDto<any>>;
+    /**
+     * Process daily login
+     * POST /supa_points/daily_login
+     */
+    dailyLogin(): Promise<DailyLoginResponseDto>;
+    /**
+     * Check if paymaster can sponsor user operation
+     * POST /paymaster
+     */
+    checkPaymasterSponsorship(request: PaymasterRequestDto): Promise<PaymasterResponseDto>;
+    /**
+     * Get Privy balance
+     * GET /privy/balance
+     */
+    getPrivyBalance(): Promise<any>;
+}
+
+/**
+ * Converts base64 string to Uint8Array
+ * @param base64 - Base64 encoded string
+ * @returns Byte array
+ */
+export declare const base64ToBytes: (base64: string) => Uint8Array;
+
+/**
+ * Converts base64 string to hex format
+ * @param base64 - Base64 encoded string
+ * @returns Hex string with 0x prefix
+ * @example
+ * ```ts
+ * const hex = base64ToHex('SGVsbG8=');
+ * console.log(hex); // "0x48656c6c6f"
+ * ```
+ */
+export declare const base64ToHex: (base64: string) => string;
+
+/**
+ * Converts Uint8Array to base64 string
+ * @param bytes - Byte array to convert
+ * @returns Base64 encoded string
+ */
+export declare const bytesToBase64: (bytes: Uint8Array) => string;
+
+export declare interface CantonActiveContract {
+    /** Contract ID */
+    contractId: string;
+    /** Template ID */
+    templateId: string;
+    /** Contract blob data (untyped) */
+    blob: unknown;
+}
+
+/** Active contract response item from API */
+export declare interface CantonActiveContractItem {
+    /** Workflow ID (can be empty) */
+    workflowId: string;
+    /** Contract entry containing the active contract */
+    contractEntry: CantonContractEntry;
+}
+
+/** Response from /canton/api/active_contracts */
+export declare type CantonActiveContractsResponseDto = CantonActiveContractItem[];
+
+/** Amount with rate decay for Canton Amulet */
+export declare interface CantonAmuletAmount {
+    /** Initial amount as decimal string */
+    initialAmount: string;
+    /** Round number when created */
+    createdAt: {
+        number: string;
+    };
+    /** Rate per round for decay */
+    ratePerRound: {
+        rate: string;
+    };
+}
+
+/** Create argument for Canton Amulet contract */
+export declare interface CantonAmuletCreateArgument {
+    /** DSO party ID */
+    dso: string;
+    /** Owner party ID */
+    owner: string;
+    /** Amount with rate */
+    amount: CantonAmuletAmount;
+}
+
+/** Contract entry wrapper */
+export declare interface CantonContractEntry {
+    JsActiveContract: CantonJsActiveContract;
+}
+
+/** Created event for Canton contract */
+export declare interface CantonCreatedEvent {
+    /** Offset in ledger */
+    offset: number;
+    /** Node ID */
+    nodeId: number;
+    /** Contract ID */
+    contractId: string;
+    /** Template ID in format packageId:module:entity */
+    templateId: string;
+    /** Contract key (can be null) */
+    contractKey: unknown | null;
+    /** Create argument data */
+    createArgument: CantonAmuletCreateArgument | Record<string, unknown>;
+    /** Created event blob (base64) */
+    createdEventBlob: string;
+    /** Interface views */
+    interfaceViews: unknown[];
+    /** Witness parties */
+    witnessParties: string[];
+    /** Signatories */
+    signatories: string[];
+    /** Observers */
+    observers: string[];
+    /** Created timestamp (ISO 8601) */
+    createdAt: string;
+    /** Package name */
+    packageName: string;
+    /** Representative package ID */
+    representativePackageId: string;
+    /** ACS delta flag */
+    acsDelta: boolean;
+}
+
+/** Lock information for locked UTXO */
+export declare interface CantonHoldingLockDto {
+    /** Party IDs holding the lock */
+    holders: string[];
+    /** Lock expiration timestamp (ISO 8601, can be null) */
+    expiresAt: string | null;
+    /** Relative expiration duration (can be null) */
+    expiresAfter: Record<string, unknown> | null;
+    /** Context describing why the UTXO is locked (can be null) */
+    context: string | null;
+}
+
+/** Canton instrument/token identifier */
+export declare interface CantonInstrumentIdDto {
+    /** DSO party ID (instrument administrator) */
+    admin: string;
+    /** Token identifier (e.g., "Amulet" for Canton Coin) */
+    id: string;
+}
+
+/** Active contract in Canton */
+export declare interface CantonJsActiveContract {
+    /** Created event with all contract details */
+    createdEvent: CantonCreatedEvent;
+    /** Synchronizer ID */
+    synchronizerId: string;
+    /** Reassignment counter */
+    reassignmentCounter: number;
+}
+
+/** Locked UTXO with lock information */
+export declare interface CantonLockedUtxoDto {
+    /** Contract ID of the locked UTXO */
+    contractId: string;
+    /** Locked amount as decimal string */
+    amount: string;
+    /** Lock information including holders, expiration, and context */
+    lock: CantonHoldingLockDto;
+    /** UTXO metadata including creation info and demurrage rate */
+    metadata: CantonUtxoMetadataDto;
+}
+
+export declare interface CantonMeResponseDto {
+    /** Canton party ID */
+    partyId: string;
+    /** User email (can be null if not set) */
+    email: string | null;
+    /** Indicates whether the transfer preapproval is set and NOT EXPIRED for the party */
+    transferPreapprovalSet: boolean;
+    /** Transfer preapproval expiration date (ISO 8601, can be null) */
+    transferPreapprovalExpiresAt: string | null;
+}
+
+/** Request for preparing Amulet (Canton Coin) transfer */
+export declare interface CantonPrepareAmuletTransferRequestDto {
+    /** Canton party ID of the receiver wallet */
+    receiverPartyId: string;
+    /** Amount of Amulet to transfer (decimal string with max 10 decimal places) */
+    amount: string;
+    /** Optional memo for the transfer */
+    memo?: string;
+}
+
+export declare interface CantonPrepareRegisterRequestDto {
+    /** Base64 stellar public key from privy */
+    publicKey: string;
+}
+
+export declare interface CantonPrepareTapRequestDto {
+    /** Positive integer amount of how many canton coins to receive */
+    amount: string;
+}
+
+export declare interface CantonPrepareTransactionRequestDto {
+    /** Command or array of commands */
+    commands: unknown;
+    /** Optional disclosed contracts */
+    disclosedContracts?: unknown;
+}
+
+export declare interface CantonPrepareTransactionResponseDto {
+    /** Base64 hash to be signed by the user */
+    hash: string;
+}
+
+export declare interface CantonQueryCompletionResponseDto {
+    /** Status of the completion query */
+    status: CantonQueryCompletionStatus;
+    /** Completion data (nullable, present when status is 'completed') */
+    data: Record<string, unknown> | null;
+    /** Message explaining the status */
+    message: string;
+}
+
+export declare type CantonQueryCompletionStatus = 'completed' | 'unknown';
+
+export declare interface CantonRegisterParams {
+    /** Base64 public key from Stellar wallet */
+    publicKey: string;
+    /** Function to sign hash (returns signature in hex) */
+    signFunction: (hashHex: string) => Promise<string>;
+}
+
+export declare class CantonService {
+    private client;
+    constructor(client: ApiClient);
+    /**
+     * Register Canton wallet
+     * Flow:
+     * 1. Call /canton/register/prepare with publicKey -> get hash
+     * 2. Sign hash with Stellar wallet
+     * 3. Call /canton/register/submit with hash + signature
+     *
+     * @param params Registration parameters
+     */
+    registerCanton(params: CantonRegisterParams, errCounter?: number): Promise<void>;
+    /**
+     * Tap devnet faucet to receive test Canton coins
+     * Flow:
+     * 1. Call /canton/devnet/tap with amount -> get hash
+     * 2. Sign hash with Stellar wallet
+     * 3. Call /canton/api/submit_prepared with hash + signature
+     * 4. Poll for completion
+     *
+     * @param params Tap parameters
+     * @param options Polling options
+     */
+    tapDevnet(params: CantonTapParams, options?: CantonSubmitPreparedOptions): Promise<CantonQueryCompletionResponseDto>;
+    /**
+     * Submit signed Canton transaction
+     * @param hash Base64 hash
+     * @param signature Base64 signature
+     */
+    submitPrepared(hash: string, signature: string): Promise<CantonSubmitTransactionResponseDto>;
+    /**
+     * Query completion status for a submission
+     * @param submissionId Submission ID from submitPrepared
+     */
+    queryCompletion(submissionId: string): Promise<CantonQueryCompletionResponseDto>;
+    /**
+     * Submit signed Canton transaction and wait for completion
+     * Polls the ledger API until the transaction is completed or timeout is reached
+     * @param hash Base64 hash
+     * @param signature Base64 signature
+     * @param options Polling options (timeout, pollInterval)
+     * @returns Completion data when transaction is completed
+     * @throws Error if timeout is reached before completion
+     */
+    submitPreparedAndWait(hash: string, signature: string, options?: CantonSubmitPreparedOptions): Promise<CantonQueryCompletionResponseDto>;
+    /**
+     * Get current Canton user info (partyId and email)
+     * Only works after registration
+     */
+    getMe(): Promise<CantonMeResponseDto>;
+    /**
+     * Get active contracts with optional template filtering
+     * Returns array of active contract items with full contract details
+     * @param templateIds Optional array of template IDs to filter by
+     */
+    getActiveContracts(templateIds?: string[]): Promise<CantonActiveContractsResponseDto>;
+    /**
+     * Sign text message (client-side only, no backend call)
+     * Converts text to bytes and signs with Stellar wallet
+     * @param message Text message to sign
+     * @param signFunction Function to sign hash (returns signature in hex)
+     */
+    signMessage(message: string, signFunction: (hashHex: string) => Promise<string>): Promise<string>;
+    /**
+     * Prepare Canton transaction
+     * @param commands Command or array of commands
+     * @param disclosedContracts Optional disclosed contracts
+     */
+    prepareTransaction(commands: unknown, disclosedContracts?: unknown): Promise<CantonPrepareTransactionResponseDto>;
+    /**
+     * Check if user has Canton wallet registered
+     * This is inferred - if /me succeeds, user has wallet
+     */
+    checkRegistrationStatus(): Promise<boolean>;
+    /**
+     * Prepare transfer preapproval
+     * Flow: prepare -> sign -> submit
+     * No request body required
+     */
+    prepareTransferPreapproval(): Promise<CantonPrepareTransactionResponseDto>;
+    /**
+     * Get Canton wallet balances
+     * Returns balances for all tokens grouped by instrument ID
+     * Includes unlocked and locked UTXOs
+     */
+    getBalances(): Promise<CantonWalletBalancesResponseDto>;
+    /**
+     * Prepare Amulet (Canton Coin) transfer
+     * @param params Transfer parameters (receiverPartyId, amount, memo)
+     * @throws Error if amount has more than 10 decimal places
+     */
+    prepareAmuletTransfer(params: CantonPrepareAmuletTransferRequestDto): Promise<CantonPrepareTransactionResponseDto>;
+}
+
+export declare interface CantonSubmitPreparedOptions {
+    /** Timeout in milliseconds to wait for completion (default: 30000) */
+    timeout?: number;
+    /** Polling interval in milliseconds (default: 1000) */
+    pollInterval?: number;
+}
+
+export declare interface CantonSubmitRegisterRequestDto {
+    /** Base64 hash provided for signing */
+    hash: string;
+    /** Base64 signature for provided hash */
+    signature: string;
+}
+
+export declare interface CantonSubmitTransactionResponseDto {
+    /** Submission ID for tracking completion */
+    submissionId: string;
+}
+
+export declare interface CantonTapParams {
+    /** Amount of Canton coins to receive */
+    amount: string;
+    /** Function to sign hash (returns signature in hex) */
+    signFunction: (hashHex: string) => Promise<string>;
+}
+
+/** Token balance with unlocked and locked UTXOs */
+export declare interface CantonTokenBalanceDto {
+    /** Unique identifier for this token type */
+    instrumentId: CantonInstrumentIdDto;
+    /** Total unlocked balance as decimal string */
+    totalUnlockedBalance: string;
+    /** Total locked balance as decimal string */
+    totalLockedBalance: string;
+    /** Total balance (unlocked + locked) as decimal string */
+    totalBalance: string;
+    /** Number of unlocked UTXOs */
+    unlockedUtxoCount: number;
+    /** Number of locked UTXOs */
+    lockedUtxoCount: number;
+    /** List of unlocked UTXOs */
+    unlockedUtxos: CantonUnlockedUtxoDto[];
+    /** List of locked UTXOs */
+    lockedUtxos: CantonLockedUtxoDto[];
+}
+
+/** Unlocked UTXO */
+export declare interface CantonUnlockedUtxoDto {
+    /** Contract ID of the UTXO */
+    contractId: string;
+    /** Amount as decimal string */
+    amount: string;
+    /** UTXO metadata including creation info and demurrage rate */
+    metadata: CantonUtxoMetadataDto;
+}
+
+/** UTXO metadata including creation info and demurrage rate */
+export declare interface CantonUtxoMetadataDto {
+    /** Round number when the UTXO was created */
+    createdInRound: string;
+    /** Demurrage rate per round (balance decrease rate for Canton Coin) */
+    demurrageRate: string;
+}
+
+/** Canton wallet balances response */
+export declare interface CantonWalletBalancesResponseDto {
+    /** Party ID of the wallet owner */
+    partyId: string;
+    /** Token balances grouped by instrument ID */
+    tokens: CantonTokenBalanceDto[];
+    /** Timestamp when balances were fetched (ISO 8601) */
+    fetchedAt: string;
+}
+
+export declare interface ClientConfig {
+    baseURL?: string;
+    nodeIdentifier: string;
+    getAccessToken?: () => Promise<string | null>;
+}
+
+export declare function ConfirmationModal({ open, onClose, onConfirm, onReject, title, message, confirmText, rejectText, description, infoText, icon, loading, }: ConfirmationModalProps): JSX.Element;
+
+export declare interface ConfirmationModalProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onReject: () => void;
+    title?: ReactNode;
+    message: string;
+    confirmText?: string;
+    rejectText?: string;
+    description?: string;
+    infoText?: string;
+    icon?: ReactNode;
+    loading?: boolean;
+}
+
+export declare interface ConfirmModalOptions {
+    title?: string;
+    message: string;
+    confirmText?: string;
+    rejectText?: string;
+    description?: string;
+    icon?: ReactNode;
+}
+
+export declare function createApiClient(config?: ClientConfig): ApiClient;
+
+export declare interface DailyLoginResponseDto {
+    /** Current SupaPoints balance */
+    balance: number;
+    /** SupaPoints balance change */
+    add: number;
+}
+
+export declare interface DialogListResponseDto {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    isProcessingNow: boolean;
+    firstMessage: string;
+}
+
+export declare interface DialogWithMessagesResponseDto {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    isProcessingNow: boolean;
+    messages: MessageResponseDto[];
+}
+
+export declare function getApiClient(): ApiClient;
+
+/**
+ * Gets the first Stellar wallet from user and wallets array
+ * Convenience function that throws if no Stellar wallet is found
+ *
+ * @param user - Privy user object
+ * @param wallets - Privy wallets array from useWallets hook
+ * @returns First Stellar wallet found
+ * @throws {Error} If no Stellar wallet found
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const wallet = getFirstStellarWallet(user, wallets);
+ *   console.log('Using wallet:', wallet.address);
+ * } catch (err) {
+ *   console.error('No Stellar wallet available');
+ * }
+ * ```
+ */
+export declare const getFirstStellarWallet: (user: any, wallets: any[]) => StellarWallet;
+
+export declare interface GetPricesByAddressesBodyDto {
+    /** Array of pairs of alchemy network and contract address */
+    addresses: Array<{
+        network: AlchemyNetwork;
+        contractAddress: string;
+    }>;
+}
+
+/**
+ * Converts Stellar wallet public key to Canton Network base64 format
+ * Handles removal of leading 00 byte and conversion from hex to base64
+ *
+ * @param wallet - Stellar wallet object containing publicKey
+ * @returns Public key in base64 format ready for Canton Network API
+ * @throws {Error} If wallet is invalid or publicKey is missing/malformed
+ *
+ * @example
+ * ```ts
+ * const publicKeyBase64 = getPublicKeyBase64(stellarWallet);
+ * // Use with Canton Network API
+ * await fetch('/canton/register/prepare', {
+ *   body: JSON.stringify({ publicKey: publicKeyBase64 })
+ * });
+ * ```
+ */
+export declare const getPublicKeyBase64: (wallet: StellarWallet | any) => string;
+
+/**
+ * Extracts all Stellar wallets from Privy user and wallets array
+ * Combines wallets from both user.linkedAccounts and useWallets hook,
+ * removing duplicates by address.
+ *
+ * @param user - Privy user object
+ * @param wallets - Privy wallets array from useWallets hook
+ * @returns Array of unique Stellar wallets
+ *
+ * @example
+ * ```ts
+ * const { user } = usePrivy();
+ * const { wallets } = useWallets();
+ * const stellarWallets = getStellarWallets(user, wallets);
+ * console.log(`Found ${stellarWallets.length} Stellar wallets`);
+ * ```
+ */
+export declare const getStellarWallets: (user: any, wallets: any[]) => StellarWallet[];
+
+export declare interface GetTokens24hrPriceChangeParams {
+    /** Array of pairs of alchemy network and contract address */
+    tokens: Array<{
+        network: AlchemyNetwork;
+        contractAddress: string;
+    }>;
+}
+
+/**
+ * Converts hex string to base64 format
+ * @param hex - Hex string (with or without 0x prefix)
+ * @returns Base64 encoded string
+ * @example
+ * ```ts
+ * const base64 = hexToBase64('0x48656c6c6f');
+ * console.log(base64); // "SGVsbG8="
+ * ```
+ */
+export declare const hexToBase64: (hex: string) => string;
+
+/**
+ * Type guard to check if a wallet is a Stellar wallet
+ * @param wallet - Wallet object to check
+ * @returns True if wallet is a valid Stellar wallet
+ *
+ * @example
+ * ```ts
+ * if (isStellarWallet(wallet)) {
+ *   console.log('Stellar wallet address:', wallet.address);
+ * }
+ * ```
+ */
+export declare const isStellarWallet: (wallet: any) => wallet is StellarWallet;
+
+export declare interface MessageResponseDto {
+    id: number;
+    dialogId: number;
+    text: string;
+    isReply: boolean;
+    date: string;
+    command?: any | null;
+    payload?: any | null;
+    actionSuggestions?: any | null;
+}
+
+export declare interface ModalResult<T = void> {
+    confirmed: boolean;
+    data?: T;
+}
+
+export declare interface NetworkAddressAndPriceDto {
+    /** Alchemy network */
+    network: string;
+    /** Contract address */
+    contractAddress: string;
+    /** USD price */
+    price: number;
+}
+
+export declare interface NewDialogRequestDto {
+    text: string;
+}
+
+export declare interface NewMessageRequestDto {
+    /** Message text content */
+    text: string;
+}
+
+export declare interface OffsetPaginatedDto<T = any> {
+    data: T[];
+    pagination: OffsetPaginationDto;
+}
+
+export declare interface OffsetPaginationDto {
+    limit: number;
+    currentPage: number;
+}
+
+/**
+ * TypeScript types generated from Supa Backend API Swagger
+ * Based on OpenAPI 3.0.0 specification
+ */
+export declare type Order = 'ASC' | 'DESC';
+
+export declare interface PaginationParams {
+    limit?: number;
+    page?: number;
+    order?: Order;
+}
+
+export declare interface PaymasterRequestDataDto {
+    /** User operation hex-string */
+    userOperation: string;
+    /** Entrypoint address */
+    entryPoint: string;
+    /** Network ID */
+    chainId: number;
+    /** Sponsorship policy ID */
+    sponsorshipPolicyId: string;
+}
+
+export declare interface PaymasterRequestDto {
+    /** Request type */
+    type: 'sponsorshipPolicy.webhook';
+    /** Request data */
+    data: PaymasterRequestDataDto;
+}
+
+export declare interface PaymasterResponseDto {
+    sponsor: boolean;
+}
+
+/**
+ * Converts Privy public key (hex with leading 00) to Canton format (base64 without leading 00)
+ * This function handles the conversion from Privy's Stellar wallet public key format
+ * to Canton Network's expected base64 format.
+ *
+ * @param publicKeyHex - Public key in hex format from Privy (may include 0x prefix and leading 00)
+ * @returns Public key in base64 format for Canton Network
+ * @throws {Error} If conversion fails
+ *
+ * @example
+ * ```ts
+ * const wallet = { publicKey: '00e95cb2553361ed...' };
+ * const cantonKey = privyPublicKeyToCantonBase64(wallet.publicKey);
+ * // Use cantonKey for Canton Network API calls
+ * ```
+ */
+export declare const privyPublicKeyToCantonBase64: (publicKeyHex: string) => string;
+
+export declare 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 declare function SignMessageModal({ open, onClose, onConfirm, onReject, message, loading, title, description, confirmText, rejectText, }: SignMessageModalProps): JSX.Element;
+
+export declare interface SignMessageModalOptions {
+    message: string;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+}
+
+export declare interface SignMessageModalProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onReject: () => void;
+    message: string;
+    loading?: boolean;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+}
+
+export declare 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 declare 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;
+}
+
+declare type SignRawHashParams = Parameters<ReturnType<typeof useSignRawHash>['signRawHash']>[0];
+
+export declare function SignTransactionModal({ open, onClose, onConfirm, onReject, transaction, loading, title, description, confirmText, rejectText, infoText, }: SignTransactionModalProps): JSX.Element;
+
+export declare interface SignTransactionModalOptions {
+    transaction: string;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+    infoText?: string;
+}
+
+export declare interface SignTransactionModalProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onReject: () => void;
+    transaction: string;
+    loading?: boolean;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+    infoText?: string;
+}
+
+/**
+ * Stellar wallet utilities for Privy integration
+ * Stellar chain type is used for Ed25519 signing required by Canton Network
+ */
+/**
+ * Stellar wallet interface representing a Privy Stellar wallet
+ */
+export declare interface StellarWallet {
+    /** Stellar address (public key in Stellar format) */
+    address: string;
+    /** Raw public key in hex format */
+    publicKey: string;
+    /** Chain type, always 'stellar' for Stellar wallets */
+    chainType: 'stellar';
+    /** Wallet client type (e.g., 'privy') */
+    walletClientType?: string;
+    /** Whether the wallet was imported or created */
+    imported?: boolean;
+}
+
+/**
+ * Removes leading 00 byte from hex string if present
+ * Required for Stellar public keys from Privy which include a leading 00 byte
+ * @param hex - Hex string (with or without 0x prefix)
+ * @returns Clean hex string with 0x prefix
+ * @example
+ * ```ts
+ * const clean = stripLeadingZero('0x00e95cb2553361ed...');
+ * console.log(clean); // "0xe95cb2553361ed..."
+ * ```
+ */
+export declare const stripLeadingZero: (hex: string) => string;
+
+export declare interface SupaConfig {
+    privyAppId: string;
+    privyClientId?: string;
+    apiBaseUrl?: string;
+    nodeIdentifier: string;
+    appearance?: {
+        theme?: 'light' | 'dark';
+        accentColor?: string;
+        logo?: string;
+    };
+    loginMethods?: Array<'email' | 'wallet' | 'google' | 'twitter' | 'discord' | 'github' | 'linkedin'>;
+    smartWallets?: {
+        enabled?: boolean;
+        paymasterContext?: {
+            mode?: string;
+            calculateGasLimits?: boolean;
+            expiryDuration?: number;
+            sponsorshipInfo?: {
+                webhookData?: Record<string, any>;
+                smartAccountInfo?: {
+                    name?: string;
+                    version?: string;
+                };
+            };
+        };
+    };
+}
+
+export declare interface SupaContextValue {
+    apiClient: ApiClient;
+    cantonService: CantonService;
+    apiService: ApiService;
+    config: SupaConfig;
+    theme: 'light' | 'dark';
+    confirm: (options: ConfirmModalOptions) => Promise<ModalResult>;
+    signMessageConfirm: (options: SignMessageModalOptions) => Promise<ModalResult>;
+    signTransactionConfirm: (options: SignTransactionModalOptions) => Promise<ModalResult>;
+    setModalLoading: (loading: boolean) => void;
+    closeModal: () => void;
+}
+
+export declare interface SupaPointsBalanceResponseDto {
+    /** Current SupaPoints balance */
+    balance: number;
+}
+
+export declare interface SupaPointsHistoryParams extends PaginationParams {
+    startDate?: string;
+    endDate?: string;
+    action?: string;
+}
+
+export declare function SupaProvider({ config, children }: SupaProviderProps): JSX.Element | null;
+
+export declare interface SupaProviderProps {
+    config: SupaConfig;
+    children: ReactNode;
+}
+
+export declare type TimeInterval = 'ONE_HOUR' | 'ONE_DAY' | 'ONE_MONTH' | 'ONE_YEAR' | 'ALL_TIME';
+
+export declare interface TokenInfo {
+    network: string;
+    logo: string;
+    name: string;
+    website: string;
+    description: string;
+    explorer: string;
+    type: string;
+    symbol: string;
+    decimals: number;
+    status: string;
+    tags: string[];
+    id: string;
+    links: any[];
+}
+
+export declare interface TokenInfoWithPriceChangeDto {
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token logo */
+    logo: string;
+    /** Token description */
+    description?: string | null;
+    /** Decimals */
+    decimals: number;
+    /** Contract address */
+    contractAddress: string;
+    /** Network */
+    network: string;
+    /** Native token flag */
+    native: boolean;
+    /** Price change */
+    priceChange: TokenPriceChange;
+}
+
+export declare interface TokenPriceChange {
+    currentPrice: number;
+    oldPrice: number;
+    priceChangeAbsolute: number;
+    priceChangePercentage: number;
+}
+
+export declare interface TokenPriceHistoryDataPoint {
+    value: string;
+    timestamp: string;
+}
+
+export declare interface TokenPriceHistoryParams {
+    contractAddress: string;
+    network: AlchemyNetwork;
+    interval?: TimeInterval;
+    limit?: number;
+    page?: number;
+    order?: Order;
+}
+
+export declare interface TokenPriceHistoryResponse {
+    symbol: string;
+    currency: string;
+    data: TokenPriceHistoryDataPoint[];
+}
+
+export declare interface TransactionQueryParams {
+    withScam?: boolean;
+}
+
+/**
+ * Return type for useAPI hook
+ * Provides organized access to all backend API methods
+ */
+declare 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 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;
+
+/**
+ * Return type for useAuth hook
+ */
+export declare 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: User | null;
+    /** Gets Privy JWT access token for authenticated API calls */
+    getAccessToken: () => Promise<string | null>;
+    /** Whether SDK is ready (not loading) */
+    ready: boolean;
+}
+
+/**
+ * Hook for Canton Network operations
+ */
+export declare function useCanton(): UseCantonReturn;
+
+export declare interface UseCantonReturn {
+    /** 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: () => 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?: CantonSubmitPreparedOptions) => Promise<CantonQueryCompletionResponseDto>;
+    /** Setup transfer preapproval (internal, called automatically) */
+    setupTransferPreapproval: () => Promise<void>;
+    /** Loading state */
+    loading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Clear error */
+    clearError: () => void;
+}
+
+export declare function useConfirmModal(): UseConfirmModalReturn;
+
+export declare 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: SignTransactionModalOptions) => Promise<ModalResult>;
+    /** Set loading state for current modal */
+    setModalLoading: (loading: boolean) => void;
+    /** Close current modal */
+    closeModal: () => void;
+}
+
+export declare interface UserBalanceEntryDto {
+    /** Token contract address */
+    contractAddress: string;
+    /** Token balance as a big integer string */
+    tokenBalance: string;
+    /** Token balance as a human-readable decimal string */
+    tokenBalanceDecimal: string;
+    /** Token decimals */
+    decimals: number;
+    /** Token logo URL */
+    logoUrl: string;
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** Network name */
+    network: string;
+}
+
+export declare interface UserBalanceResponseDto {
+    /** Wallet address */
+    address: string;
+    /** List of token balances */
+    balances: UserBalanceEntryDto[];
+    /** Total USD balance. Decimal string */
+    totalUsdBalance: string;
+}
+
+export declare interface UserResponseDto {
+    [key: string]: any;
+}
+
+export declare function useSendTransaction(): UseSendTransactionReturn;
+
+export declare 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 useSignMessage(): UseSignMessageReturn;
+
+export declare 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 useSignRawHashWithModal(): UseSignRawHashWithModalReturn;
+
+export declare interface UseSignRawHashWithModalReturn {
+    /** Sign a raw hash with confirmation modal */
+    signRawHashWithModal: (params: SignRawHashParams, modalOptions?: SignRawHashModalOptions) => Promise<{
+        signature: string;
+    } | null>;
+}
+
+/**
+ * Hook for using Privy Smart Wallets
+ * Must be used within SmartWalletsProvider (automatically enabled in SupaProvider when smartWallets.enabled = true)
+ */
+export declare function useSmartWallets(): UseSmartWalletsReturn;
+
+export declare interface UseSmartWalletsReturn {
+    /** Client for interacting with smart wallets */
+    client: ReturnType<typeof useSmartWallets_2>['client'];
+    /** Get client for specific chain */
+    getClientForChain: ReturnType<typeof useSmartWallets_2>['getClientForChain'];
+    /** Get user's smart wallet address */
+    address: string | undefined;
+    /** Whether smart wallets are ready to use */
+    ready: boolean;
+}
+
+export declare function useStellarWallet(): UseStellarWalletReturn;
+
+export declare interface UseStellarWalletReturn {
+    stellarWallets: StellarWallet[];
+    stellarWallet: StellarWallet | null;
+}
+
+/**
+ * Main hook for accessing all Supa SDK features
+ * Combines authentication, Canton Network, and API functionality
+ *
+ * @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>
+ *   );
+ * }
+ * ```
+ */
+declare const useSupa: () => UseSupaReturn;
+export { useSupa }
+export { useSupa as useWalletino }
+
+export declare function useSupaContext(): SupaContextValue;
+
+/**
+ * Return type for useSupa hook
+ */
+declare 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>;
+}
+export { UseSupaReturn }
+export { UseSupaReturn as UseWalletinoReturn }
+
+export { }