@supanovaapp/sdk 0.2.12 → 0.2.13

package/dist/providers/SupaProvider.d.ts

@@ -0,0 +1,82 @@
+import { ReactNode } from 'react';
+import { ApiClient } from '../core/client';
+import { CantonService } from '../services/cantonService';
+import { ApiService } from '../services/apiService';
+export 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' | 'telegram'>;
+    smartWallets?: {
+        enabled?: boolean;
+        paymasterContext?: {
+            mode?: string;
+            calculateGasLimits?: boolean;
+            expiryDuration?: number;
+            sponsorshipInfo?: {
+                webhookData?: Record<string, any>;
+                smartAccountInfo?: {
+                    name?: string;
+                    version?: string;
+                };
+            };
+        };
+    };
+    /** Default chain for smart wallets and transactions */
+    defaultChain?: any;
+    /** Supported chains for the app */
+    supportedChains?: any[];
+    /** Enable automatic onboarding (create wallet + register Canton on login). Default: true */
+    autoOnboarding?: boolean;
+}
+export interface ConfirmModalOptions {
+    title?: string;
+    message: string;
+    confirmText?: string;
+    rejectText?: string;
+    description?: string;
+    icon?: ReactNode;
+}
+export interface SignTransactionOptions {
+    transaction: string;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+    infoText?: string;
+}
+export interface ModalResult<T = void> {
+    confirmed: boolean;
+    data?: T;
+}
+export interface SignMessageModalOptions {
+    message: string;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+}
+export 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: SignTransactionOptions) => Promise<ModalResult>;
+    setModalLoading: (loading: boolean) => void;
+    closeModal: () => void;
+}
+export interface SupaProviderProps {
+    config: SupaConfig;
+    children: ReactNode;
+}
+export declare function SupaProvider({ config, children }: SupaProviderProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function useSupaContext(): SupaContextValue;

package/dist/services/apiService.d.ts

@@ -0,0 +1,163 @@
+import { ApiClient } from '../core/client';
+import { UserResponseDto, UserBalanceResponseDto, DialogWithMessagesResponseDto, DialogListResponseDto, OffsetPaginatedDto, MessageResponseDto, PaginationParams, NetworkAddressAndPriceDto, TokenInfoWithPriceChangeDto, TokenInfo, TokenPriceHistoryParams, TokenPriceHistoryResponse, AccountTokensBalancesResponse, AlchemyNetwork, SupaPointsBalanceResponseDto, DailyLoginResponseDto, SupaPointsHistoryParams, TransactionQueryParams, PaymasterRequestDto, PaymasterResponseDto } from '../core/types';
+export declare class ApiService {
+    private client;
+    private userMeCache;
+    private userMeCacheTimestamp;
+    private userMePendingPromise;
+    private supaPointsBalanceCache;
+    private supaPointsBalanceCacheTimestamp;
+    private supaPointsBalancePendingPromise;
+    private privyBalanceCache;
+    private privyBalanceCacheTimestamp;
+    private privyBalancePendingPromise;
+    private readonly USER_CACHE_TTL;
+    constructor(client: ApiClient);
+    /**
+     * Инвалидация кеша /user/me
+     * Вызывается после операций, изменяющих данные пользователя
+     */
+    private invalidateUserCache;
+    /**
+     * Инвалидация кеша /supa_points/balance
+     */
+    private invalidateSupaPointsCache;
+    /**
+     * Инвалидация кеша /privy/balance
+     */
+    private invalidatePrivyBalanceCache;
+    /**
+     * Get current user information
+     * GET /user/me
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
+     */
+    getCurrentUser(force?: boolean): 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
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
+     */
+    getSupaPointsBalance(force?: boolean): 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
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
+     */
+    getPrivyBalance(force?: boolean): Promise<any>;
+}
+export declare function createApiService(client: ApiClient): ApiService;
+export declare function getApiService(): ApiService;

package/dist/services/cantonService.d.ts

@@ -0,0 +1,156 @@
+import { ApiClient } from '../core/client';
+import { CantonPrepareTransactionResponseDto, CantonSubmitTransactionResponseDto, CantonMeResponseDto, CantonActiveContractsResponseDto, CantonQueryCompletionResponseDto, CantonWalletBalancesResponseDto, CantonPrepareAmuletTransferRequestDto, CantonIncomingTransferDto, CantonPrepareResponseIncomingTransferRequestDto, CantonCostEstimationDto, CantonTransactionDto, CantonTransactionsParams, CantonPriceInterval, CantonPriceCandleDto } from '../core/types';
+export type { CantonMeResponseDto, CantonActiveContractsResponseDto, CantonPrepareTransactionResponseDto, CantonQueryCompletionResponseDto, CantonWalletBalancesResponseDto, CantonPrepareAmuletTransferRequestDto, CantonIncomingTransferDto, CantonPrepareResponseIncomingTransferRequestDto, CantonCostEstimationDto, CantonTransactionDto, CantonTransactionsParams, CantonPriceInterval, CantonPriceCandleDto, };
+export interface CantonRegisterParams {
+    /** Base64 public key from Stellar wallet */
+    publicKey: string;
+    /** Function to sign hash (returns signature in hex) */
+    signFunction: (hashHex: string) => Promise<string>;
+    /** Optional invite code */
+    inviteCode?: string;
+}
+export interface CantonTapParams {
+    /** Amount of Canton coins to receive */
+    amount: string;
+    /** Function to sign hash (returns signature in hex) */
+    signFunction: (hashHex: string) => Promise<string>;
+}
+export interface CantonSubmitPreparedOptions {
+    /** Timeout in milliseconds to wait for completion (default: 30000) */
+    timeout?: number;
+    /** Polling interval in milliseconds (default: 1000) */
+    pollInterval?: number;
+    /** Callback to receive cost estimation before signing (optional) */
+    onCostEstimation?: (costEstimation: CantonCostEstimationDto | undefined) => void | Promise<void>;
+}
+export declare class CantonService {
+    private client;
+    private meCache;
+    private meCacheTimestamp;
+    private mePendingPromise;
+    private readonly CACHE_TTL;
+    constructor(client: ApiClient);
+    /**
+     * Инвалидация кеша /me
+     * Вызывается после операций регистрации/изменения пользователя
+     */
+    private invalidateMeCache;
+    /**
+     * 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<any>;
+    /**
+     * 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
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
+     */
+    getMe(force?: boolean): 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>;
+    /**
+     * Get pending incoming transfers for the current user
+     * Returns a list of transfer offers that can be accepted or rejected
+     * @returns Array of incoming transfer DTOs
+     */
+    getPendingIncomingTransfers(): Promise<CantonIncomingTransferDto[]>;
+    /**
+     * Prepare response to incoming transfer (accept or reject)
+     * Flow: prepare -> sign -> submit
+     * @param params Request with contractId and accept flag
+     * @returns Prepare response with hash to sign
+     */
+    prepareResponseToIncomingTransfer(params: CantonPrepareResponseIncomingTransferRequestDto): Promise<CantonPrepareTransactionResponseDto>;
+    /**
+     * Get Canton transactions history with pagination
+     * @param params Pagination parameters (limit, beforeOffsetExclusive)
+     * @returns Array of transaction DTOs
+     */
+    getTransactions(params?: CantonTransactionsParams): Promise<CantonTransactionDto[]>;
+    /**
+     * Get Canton price history (candles from Bybit)
+     * @param interval Time interval: '1h' (hour), '1d' (day), '1w' (week), '1M' (month)
+     * @returns Array of price candles
+     */
+    getPriceHistory(interval: CantonPriceInterval): Promise<CantonPriceCandleDto[]>;
+}
+export declare function createCantonService(client: ApiClient): CantonService;
+export declare function getCantonService(): CantonService;

package/dist/utils/converters.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Utilities for converting between hex and base64 formats
+ * Required for Canton Network integration (Canton uses base64, Privy uses hex)
+ */
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Converts base64 string to Uint8Array
+ * @param base64 - Base64 encoded string
+ * @returns Byte array
+ */
+export declare const base64ToBytes: (base64: string) => Uint8Array;
+/**
+ * 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;
+/**
+ * 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;

package/dist/utils/stellar.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 interface StellarWallet {
+    /** Stellar address (public key in Stellar format) */
+    address: string;
+    /** Raw public key in hex format (camelCase) */
+    publicKey?: string;
+    /** Raw public key in hex format (snake_case from Privy API) */
+    public_key?: 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;
+}
+/**
+ * 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[];
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supanovaapp/sdk",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "React SDK for Supa Backend + Privy.io integration with Canton Network and EVM Smart Wallets support",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",