@supanovaapp/sdk 0.2.1 → 0.2.4

package/dist/index.d.ts

@@ -45,6 +45,7 @@ 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;
@@ -63,6 +64,8 @@ export declare class ApiClient {
     private client;
     private getAccessToken?;
     private nodeIdentifier;
+    private cache;
+    private cacheTTL;
     constructor(config?: ClientConfig);
     get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
     post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
@@ -86,12 +89,36 @@ export declare interface ApiResponse<T = any> {
 
 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(): Promise<UserResponseDto>;
+    getCurrentUser(force?: boolean): Promise<UserResponseDto>;
     /**
      * Get all users
      * GET /user/all
@@ -194,8 +221,9 @@ export declare class ApiService {
     /**
      * Get SupaPoints balance
      * GET /supa_points/balance
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
      */
-    getSupaPointsBalance(): Promise<SupaPointsBalanceResponseDto>;
+    getSupaPointsBalance(force?: boolean): Promise<SupaPointsBalanceResponseDto>;
     /**
      * Get SupaPoints history
      * GET /supa_points/history
@@ -214,8 +242,9 @@ export declare class ApiService {
     /**
      * Get Privy balance
      * GET /privy/balance
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
      */
-    getPrivyBalance(): Promise<any>;
+    getPrivyBalance(force?: boolean): Promise<any>;
 }
 
 /**
@@ -327,6 +356,26 @@ export declare interface CantonCreatedEvent {
     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 */
@@ -337,11 +386,37 @@ export declare interface CantonJsActiveContract {
     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 {
@@ -356,7 +431,7 @@ export declare interface CantonPrepareTapRequestDto {
 
 export declare interface CantonPrepareTransactionRequestDto {
     /** Command or array of commands */
-    commandId: unknown;
+    commands: unknown;
     /** Optional disclosed contracts */
     disclosedContracts?: unknown;
 }
@@ -386,7 +461,16 @@ export declare interface CantonRegisterParams {
 
 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:
@@ -433,8 +517,9 @@ export declare class CantonService {
     /**
      * Get current Canton user info (partyId and email)
      * Only works after registration
+     * С мемоизацией на 5 минут и дедупликацией одновременных запросов
      */
-    getMe(): Promise<CantonMeResponseDto>;
+    getMe(force?: boolean): Promise<CantonMeResponseDto>;
     /**
      * Get active contracts with optional template filtering
      * Returns array of active contract items with full contract details
@@ -450,16 +535,33 @@ export declare class CantonService {
     signMessage(message: string, signFunction: (hashHex: string) => Promise<string>): Promise<string>;
     /**
      * Prepare Canton transaction
-     * @param commandId Command or array of commands
+     * @param commands Command or array of commands
      * @param disclosedContracts Optional disclosed contracts
      */
-    prepareTransaction(commandId: unknown, disclosedContracts?: unknown): Promise<CantonPrepareTransactionResponseDto>;
+    prepareTransaction(commands: unknown, disclosedContracts?: unknown): Promise<CantonPrepareTransactionResponseDto>;
     /**
      * Check if user has Canton wallet registered
-     * This is inferred - if registration succeeds, user has wallet
-     * If it fails with 409 or similar, wallet already exists
+     * 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 {
@@ -488,6 +590,54 @@ export declare interface CantonTapParams {
     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;
@@ -547,6 +697,10 @@ export declare interface DialogWithMessagesResponseDto {
 
 export declare function getApiClient(): ApiClient;
 
+export declare function getApiService(): ApiService;
+
+export declare function getCantonService(): CantonService;
+
 /**
  * Gets the first Stellar wallet from user and wallets array
  * Convenience function that throws if no Stellar wallet is found
@@ -881,7 +1035,26 @@ export declare interface SupaConfig {
         accentColor?: string;
         logo?: string;
     };
-    loginMethods?: Array<'email' | 'wallet' | 'google' | 'twitter' | 'discord' | 'github' | 'linkedin'>;
+    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[];
 }
 
 export declare interface SupaContextValue {
@@ -1132,12 +1305,16 @@ export declare interface UseCantonReturn {
     registerCanton: () => Promise<void>;
     /** Whether Canton wallet is registered */
     isRegistered: boolean;
-    /** Canton user info (partyId and email) */
+    /** 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 */
@@ -1145,7 +1322,11 @@ export declare interface UseCantonReturn {
     /** Sign text message */
     signMessage: (message: string) => Promise<string>;
     /** Prepare and submit transaction with polling for completion */
-    sendTransaction: (commandId: unknown, disclosedContracts?: unknown, options?: CantonSubmitPreparedOptions) => Promise<CantonQueryCompletionResponseDto>;
+    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 */
@@ -1205,7 +1386,7 @@ export declare function useSendTransaction(): UseSendTransactionReturn;
 
 export declare interface UseSendTransactionReturn {
     /** Sign and send a Canton transaction with confirmation modal */
-    sendTransaction: (commandId: unknown, disclosedContracts?: unknown, options?: SendTransactionOptions) => Promise<CantonQueryCompletionResponseDto | null>;
+    sendTransaction: (commands: unknown, disclosedContracts?: unknown, options?: SendTransactionOptions) => Promise<CantonQueryCompletionResponseDto | null>;
     loading: boolean;
     error: Error | null;
     clearError: () => void;
@@ -1234,6 +1415,23 @@ export declare interface UseSignRawHashWithModalReturn {
     } | 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 {