cilantro-react 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,616 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { SignerInfo } from 'cilantro-sdk/helpers';
+import { Transaction, PublicKey } from '@solana/web3.js';
+
+interface CilantroProviderProps {
+    children: ReactNode;
+    platformApiKey: string;
+    apiUrl?: string;
+    /** localStorage key for JWT (default: cilantro_jwt) */
+    jwtStorageKey?: string;
+    /** localStorage key for selected wallet id (default: cilantro_selected_wallet_id) */
+    walletStorageKey?: string;
+    onLoginSuccess?: () => void;
+    onLogout?: () => void;
+    onRegisterSuccess?: () => void;
+}
+declare function CilantroProvider({ children, platformApiKey, apiUrl, jwtStorageKey, walletStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, }: CilantroProviderProps): react_jsx_runtime.JSX.Element;
+
+interface User {
+    username?: string;
+    email?: string;
+    userType?: string;
+}
+interface CilantroAuthContextType {
+    user: User | null;
+    token: string | null;
+    isAuthenticated: boolean;
+    login: (usernameOrEmail: string, password: string) => Promise<void>;
+    register: (username: string, email: string, password: string, isActive?: boolean) => Promise<void>;
+    logout: () => void;
+    isLoading: boolean;
+}
+interface CilantroAuthProviderProps {
+    children: ReactNode;
+    platformApiKey: string;
+    apiUrl?: string;
+    jwtStorageKey?: string;
+    onLoginSuccess?: () => void;
+    onLogout?: () => void;
+    onRegisterSuccess?: () => void;
+}
+declare function CilantroAuthProvider({ children, platformApiKey, apiUrl, jwtStorageKey, onLoginSuccess, onLogout, onRegisterSuccess, }: CilantroAuthProviderProps): react_jsx_runtime.JSX.Element;
+declare function useCilantroAuth(): CilantroAuthContextType;
+
+interface WalletData {
+    id: string;
+    walletId: string;
+    walletName?: string;
+    address?: string;
+    walletAddress?: string;
+    chain?: string;
+    active?: boolean;
+    [key: string]: unknown;
+}
+interface WalletContextType {
+    selectedWallet: WalletData | null;
+    wallets: WalletData[];
+    selectWallet: (walletId: string) => void;
+    refreshWallets: () => Promise<void>;
+    isLoading: boolean;
+}
+interface WalletProviderProps {
+    children: ReactNode;
+    storageKey?: string;
+}
+declare function WalletProvider({ children, storageKey }: WalletProviderProps): react_jsx_runtime.JSX.Element;
+declare function useWallets(): WalletContextType;
+
+interface SignerData extends Omit<SignerInfo, "signerId"> {
+    id: string;
+    signerId: string;
+    signerType?: string;
+    signerPubkey?: string;
+    signerConfig?: {
+        email?: string;
+        phone?: string;
+        credentialId?: string;
+    };
+    deviceIdentities?: unknown[];
+    credentialId?: string;
+    authId?: string;
+    signerCategory?: "onchain" | "authenticationsigner";
+    [key: string]: unknown;
+}
+
+interface UseSignersOptions {
+    /** Wallet ID to load signers for. If not provided, uses selectedWallet?.id from context (call useWallets() in same component). */
+    walletId?: string | null;
+}
+interface UseSignersResult {
+    signers: SignerData[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+declare function useSigners(options?: UseSignersOptions): UseSignersResult;
+
+type SigningMethod = "wallet-adapter" | "sdk-signer";
+interface UseSignerSelectionOptions {
+    /** Override wallet ID; if not set, uses selected wallet from WalletProvider */
+    walletId?: string | null;
+    /** Current signing method */
+    signingMethod?: SigningMethod | null;
+}
+interface UseSignerSelectionResult {
+    selectedWalletId: string;
+    setSelectedWalletId: (id: string) => void;
+    availableSigners: SignerData[];
+    selectedSigner: SignerData | null;
+    setSelectedSigner: (signer: SignerData | null) => void;
+    isLoadingSigners: boolean;
+    reset: () => void;
+}
+declare function useSignerSelection(options?: UseSignerSelectionOptions): UseSignerSelectionResult;
+
+/**
+ * Type Utilities - common types and utilities for SDK interactions
+ */
+type ActionState<T = unknown> = {
+    status: "idle" | "loading" | "success" | "error";
+    message?: string;
+    detail?: T;
+};
+interface ErrorResponse {
+    message?: string;
+    error?: string;
+    code?: string | number;
+    status?: number;
+    statusText?: string;
+    data?: unknown;
+    stack?: string;
+    type?: string;
+}
+type ApiResponse<T> = T | {
+    data: T;
+} | {
+    success: boolean;
+    data: T;
+};
+declare function extractResponseData<T>(response: unknown): T | null;
+
+interface UseMessageSigningOptions {
+    token: string | null;
+    signingMethod: SigningMethod | null;
+    selectedSigner: SignerData | null;
+    selectedWalletId: string;
+    /** Optional: callback when using wallet-adapter; signMessage(encodedMessage) => signature bytes */
+    walletAdapterSignMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+    /** Optional: public key when using wallet-adapter (for result) */
+    walletAdapterPublicKey?: string | null;
+}
+interface UseMessageSigningResult {
+    messageText: string;
+    setMessageText: (text: string) => void;
+    signResultState: ActionState;
+    isSigning: boolean;
+    handleSign: () => Promise<void>;
+    reset: () => void;
+}
+declare function useMessageSigning(options: UseMessageSigningOptions): UseMessageSigningResult;
+
+interface UseTransactionSigningOptions {
+    token: string | null;
+    signingMethod: SigningMethod | null;
+    selectedSigner: SignerData | null;
+    selectedWalletId: string;
+    /** Optional: wallet-adapter signTransaction(transaction) => signed transaction */
+    walletAdapterSignTransaction?: (transaction: Transaction) => Promise<Transaction>;
+    /** Optional: wallet-adapter public key (for building/sending) */
+    walletAdapterPublicKey?: string | null;
+    /** Optional: connection for sending (e.g. from @solana/web3.js). Used for wallet-adapter send. */
+    connection?: {
+        sendRawTransaction: (buf: Buffer) => Promise<string>;
+        getLatestBlockhash: () => Promise<{
+            blockhash: string;
+            lastValidBlockHeight: number;
+        }>;
+        confirmTransaction: (opts: {
+            signature: string;
+            blockhash: string;
+            lastValidBlockHeight: number;
+        }) => Promise<void>;
+    } | null;
+}
+interface UseTransactionSigningResult {
+    transactionResultState: ActionState;
+    isSigningTransaction: boolean;
+    isSendingTransaction: boolean;
+    signTransaction: (transaction: Transaction) => Promise<void>;
+    signAndSendTransaction: (transaction: Transaction) => Promise<void>;
+    reset: () => void;
+}
+declare function useTransactionSigning(options: UseTransactionSigningOptions): UseTransactionSigningResult;
+
+interface WalletSelectorClassNames {
+    root?: string;
+    trigger?: string;
+    content?: string;
+    item?: string;
+}
+interface WalletSelectorProps {
+    value?: string;
+    onWalletChange?: (walletId: string, wallet: WalletData | null) => void;
+    className?: string;
+    classNames?: WalletSelectorClassNames;
+    placeholder?: string;
+    renderTrigger?: (props: {
+        selectedWallet: WalletData | null;
+        wallets: WalletData[];
+        isLoading: boolean;
+        open: boolean;
+        setOpen: (open: boolean) => void;
+    }) => React.ReactNode;
+    renderList?: (props: {
+        wallets: WalletData[];
+        selectedWallet: WalletData | null;
+        onSelect: (wallet: WalletData) => void;
+        isLoading: boolean;
+    }) => React.ReactNode;
+    children?: (props: {
+        wallets: WalletData[];
+        selectedWallet: WalletData | null;
+        selectWallet: (walletId: string) => void;
+        isLoading: boolean;
+        refreshWallets: () => Promise<void>;
+    }) => React.ReactNode;
+}
+declare function WalletSelector(props: WalletSelectorProps): react_jsx_runtime.JSX.Element;
+
+interface SignerSelectorClassNames {
+    root?: string;
+    list?: string;
+    item?: string;
+    message?: string;
+}
+interface SignerSelectorProps {
+    /** Wallet ID (signers are loaded for this wallet when used with useSigners) */
+    selectedWalletId?: string;
+    /** Available signers (from useSigners or useSignerSelection) */
+    availableSigners: SignerData[];
+    /** Currently selected signer */
+    selectedSigner: SignerData | null;
+    /** Loading state */
+    isLoadingSigners?: boolean;
+    /** Callback when user selects a signer */
+    onSignerSelect: (signer: SignerData) => void;
+    /** Root class */
+    className?: string;
+    /** Override class names for sub-elements */
+    classNames?: SignerSelectorClassNames;
+    /** Custom list render (headless) */
+    renderList?: (props: {
+        signers: SignerData[];
+        selectedSigner: SignerData | null;
+        onSelect: (signer: SignerData) => void;
+        isLoading: boolean;
+        getSignerDisplayName: (s: SignerData) => string;
+        getSignerTypeLabel: (type: string) => string;
+        getSignerUniqueId: (s: SignerData) => string;
+    }) => React.ReactNode;
+    /** Children render props */
+    children?: (props: {
+        signers: SignerData[];
+        selectedSigner: SignerData | null;
+        onSignerSelect: (signer: SignerData) => void;
+        isLoading: boolean;
+    }) => React.ReactNode;
+}
+declare function SignerSelector({ selectedWalletId, availableSigners, selectedSigner, isLoadingSigners, onSignerSelect, className, classNames, renderList, children, }: SignerSelectorProps): react_jsx_runtime.JSX.Element | null;
+
+interface DelegatedKeyData {
+    id: string;
+    walletId: string;
+    name?: string;
+    publicKey: string;
+    permissions: Record<string, unknown>;
+    isActive?: boolean;
+    createdAt?: string;
+    expiresAt?: string;
+    [key: string]: unknown;
+}
+interface DelegatedKeySelectorClassNames {
+    root?: string;
+    trigger?: string;
+    content?: string;
+    item?: string;
+    message?: string;
+}
+interface DelegatedKeySelectorProps {
+    walletId: string;
+    value?: string;
+    onChange?: (delegatedKeyId: string, key: DelegatedKeyData | null) => void;
+    filterActive?: boolean;
+    className?: string;
+    classNames?: DelegatedKeySelectorClassNames;
+    placeholder?: string;
+    children?: (props: {
+        keys: DelegatedKeyData[];
+        selectedKeyId: string | undefined;
+        onSelect: (key: DelegatedKeyData) => void;
+        isLoading: boolean;
+        error: string | null;
+        refresh: () => Promise<void>;
+    }) => React.ReactNode;
+}
+declare function DelegatedKeySelector(props: DelegatedKeySelectorProps): react_jsx_runtime.JSX.Element;
+
+interface MessageSigningFormClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    context?: string;
+    label?: string;
+    textarea?: string;
+    charCount?: string;
+    button?: string;
+    resetButton?: string;
+    result?: string;
+    resultSuccess?: string;
+    resultError?: string;
+    resultPre?: string;
+}
+interface MessageSigningFormProps {
+    /** Optional: override token (default: from useCilantroAuth) */
+    token?: string | null;
+    /** Optional: override wallet/signer (default: from useSignerSelection) */
+    selectedWalletId?: string;
+    selectedSigner?: SignerData | null;
+    signingMethod?: SigningMethod | null;
+    /** Optional: wallet-adapter sign message (when signingMethod === "wallet-adapter") */
+    walletAdapterSignMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+    walletAdapterPublicKey?: string | null;
+    /** Root class */
+    className?: string;
+    /** Override class names for sub-elements */
+    classNames?: MessageSigningFormClassNames;
+    /** Show wallet/signer context above the form (default: true when wallet/signer selected) */
+    showContext?: boolean;
+    /** Show character count below textarea (default: false) */
+    showCharCount?: boolean;
+    /** Headless: render form content */
+    children?: (props: {
+        messageText: string;
+        setMessageText: (text: string) => void;
+        signResultState: ActionState;
+        isSigning: boolean;
+        handleSign: () => Promise<void>;
+        reset: () => void;
+    }) => React.ReactNode;
+}
+declare function MessageSigningForm({ token: tokenOverride, selectedWalletId: walletIdOverride, selectedSigner: signerOverride, signingMethod: methodOverride, walletAdapterSignMessage, walletAdapterPublicKey, className, classNames, showContext, showCharCount, children, }: MessageSigningFormProps): react_jsx_runtime.JSX.Element;
+
+interface TransactionSigningFormClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    context?: string;
+    button?: string;
+    result?: string;
+    resultSuccess?: string;
+    resultError?: string;
+    resultPre?: string;
+}
+interface TransactionSigningFormProps {
+    token?: string | null;
+    selectedWalletId?: string;
+    selectedSigner?: SignerData | null;
+    signingMethod?: SigningMethod | null;
+    walletAdapterSignTransaction?: (tx: Transaction) => Promise<Transaction>;
+    walletAdapterPublicKey?: string | null;
+    connection?: {
+        sendRawTransaction: (buf: Buffer) => Promise<string>;
+        getLatestBlockhash: () => Promise<{
+            blockhash: string;
+            lastValidBlockHeight: number;
+        }>;
+        confirmTransaction: (opts: {
+            signature: string;
+            blockhash: string;
+            lastValidBlockHeight: number;
+        }) => Promise<void>;
+    } | null;
+    className?: string;
+    classNames?: TransactionSigningFormClassNames;
+    /** Show wallet/signer context above the form (default: true when wallet/signer selected) */
+    showContext?: boolean;
+    /** Headless: render content; consumer builds transaction and calls signTransaction(tx) / signAndSendTransaction(tx) */
+    children?: (props: {
+        transactionResultState: ActionState;
+        isSigningTransaction: boolean;
+        isSendingTransaction: boolean;
+        signTransaction: (transaction: Transaction) => Promise<void>;
+        signAndSendTransaction: (transaction: Transaction) => Promise<void>;
+        reset: () => void;
+    }) => React.ReactNode;
+}
+declare function TransactionSigningForm({ token: tokenOverride, selectedWalletId: walletIdOverride, selectedSigner: signerOverride, signingMethod: methodOverride, walletAdapterSignTransaction, walletAdapterPublicKey, connection, className, classNames, showContext, children, }: TransactionSigningFormProps): react_jsx_runtime.JSX.Element;
+
+interface LoginFormClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    form?: string;
+    label?: string;
+    input?: string;
+    submitButton?: string;
+    error?: string;
+}
+interface LoginFormProps {
+    className?: string;
+    classNames?: LoginFormClassNames;
+    onSuccess?: () => void;
+    onError?: (error: string) => void;
+    /** Override submit button label */
+    submitLabel?: string;
+    /** Override title */
+    title?: string;
+    /** Override description */
+    description?: string;
+    /** Render "Create account" link (e.g. to switch to register). Shown below submit. */
+    renderSwitchToRegister?: () => React.ReactNode;
+}
+declare function LoginForm({ className, classNames, onSuccess, onError, submitLabel, title, description, renderSwitchToRegister, }: LoginFormProps): react_jsx_runtime.JSX.Element;
+
+interface RegisterFormClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    form?: string;
+    label?: string;
+    input?: string;
+    submitButton?: string;
+    error?: string;
+}
+interface RegisterFormProps {
+    className?: string;
+    classNames?: RegisterFormClassNames;
+    onSuccess?: () => void;
+    onError?: (error: string) => void;
+    /** Override submit button label */
+    submitLabel?: string;
+    /** Override title */
+    title?: string;
+    /** Override description */
+    description?: string;
+    /** Default is true (user is active after registration) */
+    isActive?: boolean;
+    /** Render "Already have an account? Sign in" link. Shown below submit. */
+    renderSwitchToLogin?: () => React.ReactNode;
+}
+declare function RegisterForm({ className, classNames, onSuccess, onError, submitLabel, title, description, isActive, renderSwitchToLogin, }: RegisterFormProps): react_jsx_runtime.JSX.Element;
+
+type AuthFormMode = "login" | "register";
+interface AuthFormClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    form?: string;
+    label?: string;
+    input?: string;
+    submitButton?: string;
+    toggle?: string;
+    toggleLink?: string;
+    error?: string;
+}
+interface AuthFormProps {
+    /** Initial mode: login or register */
+    defaultMode?: AuthFormMode;
+    className?: string;
+    classNames?: AuthFormClassNames;
+    onSuccess?: () => void;
+    onError?: (error: string) => void;
+    /** Login: submit button label */
+    loginSubmitLabel?: string;
+    /** Register: submit button label */
+    registerSubmitLabel?: string;
+    /** Login: title */
+    loginTitle?: string;
+    /** Register: title */
+    registerTitle?: string;
+    /** Login: description */
+    loginDescription?: string;
+    /** Register: description */
+    registerDescription?: string;
+    /** Text for "switch to register" link */
+    switchToRegisterText?: string;
+    /** Text for "switch to login" link */
+    switchToLoginText?: string;
+    /** Default is true (user is active after registration) */
+    isActive?: boolean;
+}
+declare function AuthForm({ defaultMode, className, classNames, onSuccess, onError, loginSubmitLabel, registerSubmitLabel, loginTitle, registerTitle, loginDescription, registerDescription, switchToRegisterText, switchToLoginText, isActive, }: AuthFormProps): react_jsx_runtime.JSX.Element;
+
+interface AuthGuardClassNames {
+    root?: string;
+    fallback?: string;
+}
+interface AuthGuardProps {
+    children: ReactNode;
+    /** Shown when not authenticated. Default: <LoginForm /> */
+    fallback?: ReactNode;
+    /** Root class when showing fallback */
+    className?: string;
+    classNames?: AuthGuardClassNames;
+    /** When true, show fallback (login) instead of children when unauthenticated. When false, render null when unauthenticated. */
+    showFallback?: boolean;
+}
+/**
+ * Wraps content and shows fallback (e.g. LoginForm) when the user is not authenticated.
+ * Use inside CilantroAuthProvider.
+ */
+declare function AuthGuard({ children, fallback, className, classNames, showFallback, }: AuthGuardProps): react_jsx_runtime.JSX.Element | null;
+
+type AddSignerType = "email" | "phone" | "passkey" | "external";
+interface AddSignerFormClassNames {
+    root?: string;
+    dialog?: string;
+    form?: string;
+    label?: string;
+    input?: string;
+    submitButton?: string;
+    cancelButton?: string;
+    error?: string;
+}
+interface AddSignerFormProps {
+    walletId: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onSuccess?: () => void;
+    onCancel?: () => void;
+    onError?: (error: string) => void;
+    className?: string;
+    classNames?: AddSignerFormClassNames;
+    /** When true, render as a dialog. When false, render inline. */
+    asDialog?: boolean;
+}
+declare function AddSignerForm({ walletId, open, onOpenChange, onSuccess, onCancel, onError, className, classNames, asDialog, }: AddSignerFormProps): react_jsx_runtime.JSX.Element;
+
+interface SignerListClassNames {
+    root?: string;
+    header?: string;
+    list?: string;
+    item?: string;
+    addButton?: string;
+    message?: string;
+}
+interface SignerListProps {
+    walletId: string;
+    className?: string;
+    classNames?: SignerListClassNames;
+    /** Callback when a signer is added (e.g. to refresh parent state) */
+    onSignerAdded?: () => void;
+    /** Custom render for the list of signers */
+    children?: (props: {
+        signers: SignerData[];
+        isLoading: boolean;
+        error: string | null;
+        refresh: () => Promise<void>;
+        openAddSigner: () => void;
+    }) => React.ReactNode;
+}
+declare function SignerList({ walletId, className, classNames, onSignerAdded, children, }: SignerListProps): react_jsx_runtime.JSX.Element;
+
+declare function extractErrorMessage(error: unknown): string;
+
+declare function getSignerPublicKey(walletId: string, signer: SignerData, signerType: string, signerId: string): Promise<PublicKey>;
+
+declare function signMessageWithSigner(walletId: string, signer: SignerData, messageText: string): Promise<{
+    signature: string;
+    publicKey?: string;
+    signerType: string;
+    signer?: string;
+}>;
+
+/** Connection-like interface for sign-and-send (passkey). Consumer provides from their Solana config. */
+interface SignAndSendConnection {
+    getLatestBlockhash: (commitment?: string) => Promise<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    confirmTransaction: (opts: {
+        signature: string;
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }) => Promise<void>;
+}
+declare function signTransactionWithSigner(walletId: string, signer: SignerData, transactionBuffer: Uint8Array): Promise<{
+    signature: string;
+    signerType: string;
+}>;
+declare function signAndSendTransactionWithSigner(walletId: string, signer: SignerData, transaction: Transaction, connection?: SignAndSendConnection | null): Promise<{
+    signature: string;
+    confirmationStatus: string;
+}>;
+
+declare function getWalletData(walletId: string): Promise<{
+    walletPublicKey: PublicKey;
+    adminSignerPubkey: PublicKey;
+}>;
+
+declare const SIGNER_TYPES: {
+    readonly EMAIL: "email";
+    readonly PHONE: "phone";
+    readonly PASSKEY: "passkey";
+    readonly EXTERNAL: "external";
+    readonly API_KEY: "apiKey";
+};
+type SignerType = (typeof SIGNER_TYPES)[keyof typeof SIGNER_TYPES];
+
+export { type ActionState, AddSignerForm, type AddSignerFormClassNames, type AddSignerFormProps, type AddSignerType, type ApiResponse, AuthForm, type AuthFormClassNames, type AuthFormMode, type AuthFormProps, AuthGuard, type AuthGuardClassNames, type AuthGuardProps, type CilantroAuthContextType, CilantroAuthProvider, type CilantroAuthProviderProps, CilantroProvider, type DelegatedKeyData, DelegatedKeySelector, type DelegatedKeySelectorClassNames, type DelegatedKeySelectorProps, type ErrorResponse, LoginForm, type LoginFormClassNames, type LoginFormProps, MessageSigningForm, type MessageSigningFormClassNames, type MessageSigningFormProps, RegisterForm, type RegisterFormClassNames, type RegisterFormProps, SIGNER_TYPES, type SignAndSendConnection, type SignerData, SignerList, type SignerListClassNames, type SignerListProps, SignerSelector, type SignerSelectorClassNames, type SignerSelectorProps, type SignerType, type SigningMethod, TransactionSigningForm, type TransactionSigningFormClassNames, type TransactionSigningFormProps, type UseMessageSigningOptions, type UseMessageSigningResult, type UseSignerSelectionOptions, type UseSignerSelectionResult, type UseSignersOptions, type UseSignersResult, type UseTransactionSigningOptions, type UseTransactionSigningResult, type User, type WalletContextType, type WalletData, WalletProvider, type WalletProviderProps, WalletSelector, type WalletSelectorClassNames, type WalletSelectorProps, extractErrorMessage, extractResponseData, getSignerPublicKey, getWalletData, signAndSendTransactionWithSigner, signMessageWithSigner, signTransactionWithSigner, useCilantroAuth, useMessageSigning, useSignerSelection, useSigners, useTransactionSigning, useWallets };