@supanovaapp/sdk 0.2.1 → 0.2.3

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;
@@ -327,6 +328,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 +358,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 +403,7 @@ export declare interface CantonPrepareTapRequestDto {
 
 export declare interface CantonPrepareTransactionRequestDto {
     /** Command or array of commands */
-    commandId: unknown;
+    commands: unknown;
     /** Optional disclosed contracts */
     disclosedContracts?: unknown;
 }
@@ -450,16 +497,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 +552,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;
@@ -882,6 +994,21 @@ export declare interface SupaConfig {
         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 {
@@ -1132,12 +1259,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 +1276,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 +1340,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 +1369,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 {