@supanovaapp/sdk 0.2.12 → 0.2.14

package/README.md

@@ -165,6 +165,87 @@ function App() {
 - `nodeIdentifier` - Canton node identifier
 - `appearance` - Theme and styling options
 - `loginMethods` - Array of enabled authentication methods
+- `autoOnboarding` - Enable automatic wallet creation and Canton registration on login (default: `true`)
+
+### Disabling Auto-Onboarding (Paywall Implementation)
+
+By default, the SDK automatically creates a Stellar wallet and registers Canton when a user logs in (`autoOnboarding: true`). For applications with paywalls or invite-only access, you can disable this:
+
+```tsx
+<SupaProvider
+  config={{
+    privyAppId: 'your-privy-app-id',
+    nodeIdentifier: 'nodeId',
+    autoOnboarding: false, // Disable automatic wallet creation and Canton registration
+  }}
+>
+  <YourApp />
+</SupaProvider>
+```
+
+With `autoOnboarding: false`:
+- Users can authenticate via Privy, but won't automatically get a Canton wallet
+- You control when to call `registerCanton()` (e.g., after payment or invite code verification)
+- Enables implementation of paywalls, invite systems, or conditional access
+
+**Example: Paywall Flow**
+
+```tsx
+function PaywallApp() {
+  const { authenticated } = useAuth();
+  const { isRegistered, registerCanton } = useCanton();
+  const [hasPaid, setHasPaid] = useState(false);
+
+  if (!authenticated) {
+    return <LoginScreen />;
+  }
+
+  if (!hasPaid) {
+    return <PaywallScreen onPaymentComplete={() => setHasPaid(true)} />;
+  }
+
+  if (!isRegistered) {
+    return (
+      <button onClick={() => registerCanton()}>
+        Create Canton Wallet
+      </button>
+    );
+  }
+
+  return <MainApp />;
+}
+```
+
+**Example: Invite Code Flow**
+
+```tsx
+function InviteOnlyApp() {
+  const { authenticated } = useAuth();
+  const { isRegistered, registerCanton } = useCanton();
+  const [inviteCode, setInviteCode] = useState('');
+
+  if (!authenticated) {
+    return <LoginScreen />;
+  }
+
+  if (!isRegistered) {
+    return (
+      <div>
+        <input
+          value={inviteCode}
+          onChange={(e) => setInviteCode(e.target.value)}
+          placeholder="Enter invite code"
+        />
+        <button onClick={() => registerCanton(inviteCode)}>
+          Register with Invite
+        </button>
+      </div>
+    );
+  }
+
+  return <MainApp />;
+}
+```
 
 ---
 

package/dist/components/ConfirmationModal.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+export 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 function ConfirmationModal({ open, onClose, onConfirm, onReject, title, message, confirmText, rejectText, description, infoText, icon, loading, }: ConfirmationModalProps): import("react/jsx-runtime").JSX.Element;
+export interface SignMessageModalProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onReject: () => void;
+    message: string;
+    loading?: boolean;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+}
+export declare function SignMessageModal({ open, onClose, onConfirm, onReject, message, loading, title, description, confirmText, rejectText, }: SignMessageModalProps): import("react/jsx-runtime").JSX.Element;
+export interface SignTransactionModalProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onReject: () => void;
+    transaction: string;
+    loading?: boolean;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    rejectText?: string;
+    infoText?: string;
+}
+export declare function SignTransactionModal({ open, onClose, onConfirm, onReject, transaction, loading, title, description, confirmText, rejectText, infoText, }: SignTransactionModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/core/client.d.ts

@@ -0,0 +1,23 @@
+import { AxiosRequestConfig } from 'axios';
+export interface ClientConfig {
+    baseURL?: string;
+    nodeIdentifier: string;
+    getAccessToken?: () => Promise<string | null>;
+}
+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>;
+    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 function createApiClient(config?: ClientConfig): ApiClient;
+export declare function getApiClient(): ApiClient;

package/dist/core/types.d.ts

@@ -0,0 +1,533 @@
+/**
+ * TypeScript types generated from Supa Backend API Swagger
+ * Based on OpenAPI 3.0.0 specification
+ */
+export type Order = 'ASC' | 'DESC';
+export type AlchemyNetwork = 'eth-mainnet' | 'arb-mainnet' | 'opt-mainnet' | 'polygon-mainnet';
+export type TimeInterval = 'ONE_HOUR' | 'ONE_DAY' | 'ONE_MONTH' | 'ONE_YEAR' | 'ALL_TIME';
+export interface CantonPrepareRegisterRequestDto {
+    /** Base64 stellar public key from privy */
+    publicKey: string;
+    /** Optional invite code */
+    inviteCode?: string;
+}
+/** Cost estimation for Canton transaction */
+export interface CantonCostEstimationDto {
+    /** Timestamp when the estimation was calculated (ISO 8601) */
+    estimationTimestamp: string;
+    /** Confirmation request traffic cost estimation in micro-units */
+    confirmationRequestTrafficCostEstimation: number;
+    /** Confirmation response traffic cost estimation in micro-units */
+    confirmationResponseTrafficCostEstimation: number;
+    /** Total traffic cost estimation in micro-units */
+    totalTrafficCostEstimation: number;
+}
+export interface CantonPrepareTransactionResponseDto {
+    /** Base64 hash to be signed by the user */
+    hash: string;
+    /** Estimated cost of the transaction (optional) */
+    costEstimation?: CantonCostEstimationDto;
+}
+export interface CantonSubmitRegisterRequestDto {
+    /** Base64 hash provided for signing */
+    hash: string;
+    /** Base64 signature for provided hash */
+    signature: string;
+}
+export interface CantonSubmitTransactionResponseDto {
+    /** Submission ID for tracking completion */
+    submissionId: string;
+}
+export type CantonQueryCompletionStatus = 'completed' | 'unknown';
+export 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 interface CantonPrepareTapRequestDto {
+    /** Positive integer amount of how many canton coins to receive */
+    amount: string;
+}
+export 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;
+}
+/** Amount with rate decay for Canton Amulet */
+export 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 interface CantonAmuletCreateArgument {
+    /** DSO party ID */
+    dso: string;
+    /** Owner party ID */
+    owner: string;
+    /** Amount with rate */
+    amount: CantonAmuletAmount;
+}
+/** Created event for Canton contract */
+export 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;
+}
+/** Active contract in Canton */
+export interface CantonJsActiveContract {
+    /** Created event with all contract details */
+    createdEvent: CantonCreatedEvent;
+    /** Synchronizer ID */
+    synchronizerId: string;
+    /** Reassignment counter */
+    reassignmentCounter: number;
+}
+/** Contract entry wrapper */
+export interface CantonContractEntry {
+    JsActiveContract: CantonJsActiveContract;
+}
+/** Active contract response item from API */
+export interface CantonActiveContractItem {
+    /** Workflow ID (can be empty) */
+    workflowId: string;
+    /** Contract entry containing the active contract */
+    contractEntry: CantonContractEntry;
+}
+/** Response from /canton/api/active_contracts */
+export type CantonActiveContractsResponseDto = CantonActiveContractItem[];
+export interface CantonActiveContract {
+    /** Contract ID */
+    contractId: string;
+    /** Template ID */
+    templateId: string;
+    /** Contract blob data (untyped) */
+    blob: unknown;
+}
+export interface CantonPrepareTransactionRequestDto {
+    /** Command or array of commands */
+    commands: unknown;
+    /** Optional disclosed contracts */
+    disclosedContracts?: unknown;
+}
+/** Canton instrument/token identifier */
+export interface CantonInstrumentIdDto {
+    /** DSO party ID (instrument administrator) */
+    admin: string;
+    /** Token identifier (e.g., "Amulet" for Canton Coin) */
+    id: string;
+}
+/** UTXO metadata including creation info and demurrage rate */
+export interface CantonUtxoMetadataDto {
+    /** Round number when the UTXO was created */
+    createdInRound: string;
+    /** Demurrage rate per round (balance decrease rate for Canton Coin) */
+    demurrageRate: string;
+}
+/** Unlocked UTXO */
+export 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;
+}
+/** Lock information for locked UTXO */
+export 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;
+}
+/** Locked UTXO with lock information */
+export 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;
+}
+/** Token balance with unlocked and locked UTXOs */
+export 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[];
+}
+/** Canton wallet balances response */
+export 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;
+}
+/** Request for preparing Amulet (Canton Coin) transfer */
+export 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;
+}
+/** Canton instrument/token info for incoming transfers */
+export interface CantonInstrumentDto {
+    /** Admin party ID of the instrument */
+    admin: string;
+    /** Token identifier (e.g., "Amulet" for Canton Coin, "CBTC" for wrapped BTC) */
+    id: string;
+}
+/** Incoming transfer information */
+export interface CantonIncomingTransferDto {
+    /** Instrument details (token info) */
+    instrument: CantonInstrumentDto;
+    /** Contract ID of the transfer instruction (use this to approve or reject) */
+    contractId: string;
+    /** Sender party ID */
+    sender: string;
+    /** Receiver party ID */
+    receiver: string;
+    /** Amount to be transferred as a string */
+    amount: string;
+    /** Date when the transfer was sent/requested (ISO 8601) */
+    requestedAt: string;
+    /** Date before which the transfer must be executed (ISO 8601) */
+    executeBefore: string;
+}
+/** Request for preparing response to incoming transfer */
+export interface CantonPrepareResponseIncomingTransferRequestDto {
+    /** Contract ID received from fetching incoming transfers */
+    contractId: string;
+    /** Whether to accept (approve) or reject the incoming transfer */
+    accept: boolean;
+}
+/** Token operation in a transaction */
+export interface CantonTokenOperationDto {
+    /** Amount as decimal string */
+    amount: string;
+    /** Operation description (e.g., "Subscription fee (from locked)") */
+    description?: string;
+    /** Direction: "in", "out", "lock", "unlock" */
+    direction: 'in' | 'out' | 'lock' | 'unlock';
+    /** Token symbol (e.g., "CC" for Canton Coin) */
+    token: string;
+    /** Counterparty party ID (for transfers) */
+    counterparty?: string;
+}
+/** Canton transaction from history */
+export interface CantonTransactionDto {
+    /** Balance change (positive for incoming, negative for outgoing) */
+    balanceChange: number;
+    /** Transaction date (ISO 8601) */
+    date: string;
+    /** Additional transaction details (varies by type) */
+    details: Record<string, unknown>;
+    /** Ledger offset for pagination */
+    ledgerOffset: number;
+    /** Locked balance change */
+    lockedChange: number;
+    /** List of token operations in this transaction */
+    tokenOperations: CantonTokenOperationDto[];
+    /** Transaction type identifier */
+    type: string;
+    /** Human-readable transaction type label */
+    typeLabel: string;
+    /** Unique update ID */
+    updateId: string;
+}
+/** Parameters for fetching transactions */
+export interface CantonTransactionsParams {
+    /** Maximum number of transactions to return (1-100, default: 20) */
+    limit?: number;
+    /** Offset for pagination (exclusive). Pass oldest transaction offset from previous response */
+    beforeOffsetExclusive?: number;
+}
+/** Time interval for price history */
+export type CantonPriceInterval = '1h' | '1d' | '1w' | '1M';
+/** Price candle data point */
+export interface CantonPriceCandleDto {
+    /** Opening price */
+    open: string;
+    /** Closing price */
+    close: string;
+    /** Minimum price in the interval */
+    min: string;
+    /** Maximum price in the interval */
+    max: string;
+    /** Interval start timestamp (ISO 8601) */
+    start: string;
+    /** Interval end timestamp (ISO 8601) */
+    end: string;
+}
+export interface UserResponseDto {
+    [key: string]: any;
+}
+export 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 interface UserBalanceResponseDto {
+    /** Wallet address */
+    address: string;
+    /** List of token balances */
+    balances: UserBalanceEntryDto[];
+    /** Total USD balance. Decimal string */
+    totalUsdBalance: string;
+}
+export interface NewDialogRequestDto {
+    text: string;
+}
+export interface MessageResponseDto {
+    id: number;
+    dialogId: number;
+    text: string;
+    isReply: boolean;
+    date: string;
+    command?: any | null;
+    payload?: any | null;
+    actionSuggestions?: any | null;
+}
+export interface DialogWithMessagesResponseDto {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    isProcessingNow: boolean;
+    messages: MessageResponseDto[];
+}
+export interface DialogListResponseDto {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    isProcessingNow: boolean;
+    firstMessage: string;
+}
+export interface NewMessageRequestDto {
+    /** Message text content */
+    text: string;
+}
+export interface OffsetPaginationDto {
+    limit: number;
+    currentPage: number;
+}
+export interface OffsetPaginatedDto<T = any> {
+    data: T[];
+    pagination: OffsetPaginationDto;
+}
+export interface PaginationParams {
+    limit?: number;
+    page?: number;
+    order?: Order;
+}
+export interface GetPricesByAddressesBodyDto {
+    /** Array of pairs of alchemy network and contract address */
+    addresses: Array<{
+        network: AlchemyNetwork;
+        contractAddress: string;
+    }>;
+}
+export interface NetworkAddressAndPriceDto {
+    /** Alchemy network */
+    network: string;
+    /** Contract address */
+    contractAddress: string;
+    /** USD price */
+    price: number;
+}
+export interface GetTokens24hrPriceChangeParams {
+    /** Array of pairs of alchemy network and contract address */
+    tokens: Array<{
+        network: AlchemyNetwork;
+        contractAddress: string;
+    }>;
+}
+export interface TokenPriceChange {
+    currentPrice: number;
+    oldPrice: number;
+    priceChangeAbsolute: number;
+    priceChangePercentage: number;
+}
+export 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 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 interface TokenPriceHistoryParams {
+    contractAddress: string;
+    network: AlchemyNetwork;
+    interval?: TimeInterval;
+    limit?: number;
+    page?: number;
+    order?: Order;
+}
+export interface TokenPriceHistoryDataPoint {
+    value: string;
+    timestamp: string;
+}
+export interface TokenPriceHistoryResponse {
+    symbol: string;
+    currency: string;
+    data: TokenPriceHistoryDataPoint[];
+}
+export interface AccountTokenBalance {
+    contractAddress: string;
+    tokenBalance: string;
+    error?: any | null;
+}
+export interface AccountTokensBalancesResponse {
+    address: string;
+    tokenBalances: AccountTokenBalance[];
+}
+export interface SupaPointsBalanceResponseDto {
+    /** Current SupaPoints balance */
+    balance: number;
+}
+export interface DailyLoginResponseDto {
+    /** Current SupaPoints balance */
+    balance: number;
+    /** SupaPoints balance change */
+    add: number;
+}
+export interface SupaPointsHistoryParams extends PaginationParams {
+    startDate?: string;
+    endDate?: string;
+    action?: string;
+}
+export interface PaymasterRequestDataDto {
+    /** User operation hex-string */
+    userOperation: string;
+    /** Entrypoint address */
+    entryPoint: string;
+    /** Network ID */
+    chainId: number;
+    /** Sponsorship policy ID */
+    sponsorshipPolicyId: string;
+}
+export interface PaymasterRequestDto {
+    /** Request type */
+    type: 'sponsorshipPolicy.webhook';
+    /** Request data */
+    data: PaymasterRequestDataDto;
+}
+export interface PaymasterResponseDto {
+    sponsor: boolean;
+}
+export interface TransactionQueryParams {
+    withScam?: boolean;
+}
+export interface ApiError {
+    statusCode: number;
+    message: string;
+    error?: string;
+}
+export interface ApiResponse<T = any> {
+    data?: T;
+    error?: ApiError;
+}