@explorins/pers-signer 1.0.5

package/dist/index.d.ts

@@ -0,0 +1,1204 @@
+import * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
+import { AnyTransactionData } from '@explorins/web3-ts/types';
+export { AnyTransactionData } from '@explorins/web3-ts/types';
+import * as _explorins_pers_shared_browser from '@explorins/pers-shared/browser';
+import { TenantPublicDTO, SessionAuthContextResponseDTO, TransactionRequestResponseDTO, TransactionFormat, CampaignDTO, CampaignClaimDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+export { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
+
+/**
+ * Types for WebAuthn provider abstraction
+ */
+interface WebAuthnProvider {
+    create(challenge: any): Promise<any>;
+    sign(challenge: any): Promise<any>;
+}
+interface WebAuthnConfig {
+    relyingParty: {
+        id: string;
+        name: string;
+        origin?: string;
+    };
+}
+
+/**
+ * Key service response types and interfaces
+ */
+/**
+ * Signature response from key signing operations
+ */
+interface SignResponse {
+    id: string;
+    keyId: string;
+    requester: {
+        userId: string;
+        appId: string;
+    };
+    requestBody: {
+        hash: string;
+        kind: "Hash";
+    };
+    status: "Signed";
+    signature: {
+        r: string;
+        s: string;
+        recid: number;
+    };
+    network: "KeyECDSA";
+    dateRequested: string;
+    dateSigned: string;
+    walletId: string;
+}
+/**
+ * Authentication response from login/register operations
+ */
+interface AuthResponse {
+    token: string;
+    message?: string;
+    status?: number;
+}
+/**
+ * Registration challenge response
+ */
+interface RegistrationChallenge {
+    temporaryAuthenticationToken: string;
+    challenge: any;
+    status?: number;
+    message?: string;
+}
+/**
+ * Registration completion response
+ */
+interface RegistrationResult {
+    token: string;
+    walletId?: string;
+    status?: number;
+    message?: string;
+}
+/**
+ * Wallet listing response
+ */
+interface WalletListResponse$1 {
+    wallets: WalletItem$1[];
+    status?: number;
+    message?: string;
+}
+/**
+ * Individual wallet item
+ */
+interface WalletItem$1 {
+    id: string;
+    address: string;
+    network: string;
+    status: string;
+    signingKey?: unknown;
+    dateCreated?: string;
+    custodial?: boolean;
+    tags?: string[];
+    boundToEvmNetwork?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Hash signing request
+ */
+interface HashSigningRequest {
+    kind: "Hash";
+    hash: string;
+}
+/**
+ * EIP-712 typed data signing request
+ */
+interface TypedDataSigningRequest {
+    blockchainKind: "Evm";
+    kind: "Eip712";
+    types: Record<string, any[]>;
+    domain: any;
+    message: Record<string, any>;
+}
+/**
+ * Generic signing request
+ */
+type SigningRequest = HashSigningRequest | TypedDataSigningRequest;
+/**
+ * Signing challenge response
+ */
+interface SigningChallenge {
+    requestBody: any;
+    challenge: {
+        challengeIdentifier: string;
+        [key: string]: any;
+    };
+    status?: number;
+    message?: string;
+}
+/**
+ * User credentials for authentication
+ */
+interface UserCredentials {
+    username: string;
+    appId?: string;
+}
+/**
+ * Relying party configuration for WebAuthn
+ */
+interface RelyingPartyConfig {
+    id: string;
+    name: string;
+    origin?: string;
+}
+
+/**
+ * Authentication service for user login and registration
+ * Uses constructor-based dependency injection for WebAuthn provider
+ */
+declare class AuthenticationService {
+    private webAuthnProvider;
+    constructor(webAuthnProvider: WebAuthnProvider);
+    /**
+     * Authenticate user with username
+     * @param username - User identifier
+     * @returns Promise resolving to authentication token
+     */
+    login(username: string): Promise<string>;
+    /**
+     * Register new user with WebAuthn credential
+     * @param username - User identifier
+     * @returns Promise resolving to registration result
+     */
+    register(username: string): Promise<RegistrationResult>;
+    /**
+     * Validate authentication token (when backend supports it)
+     * @param authToken - Token to validate
+     * @returns Promise resolving to validation result
+     */
+    validateToken(authToken: string): Promise<boolean>;
+    /**
+     * Get user information (when backend supports it)
+     * @param authToken - Authentication token
+     * @returns Promise resolving to user info or null
+     */
+    getUser(authToken: string): Promise<{
+        username: string;
+    } | null>;
+}
+
+/**
+ * Wallet management service
+ * Handles wallet listing and management operations
+ */
+declare class WalletService {
+    /**
+     * List all wallets for authenticated user
+     * @param authToken - Authentication token
+     * @returns Promise resolving to wallet list
+     */
+    static listWallets(authToken: string): Promise<any>;
+    /**
+     * Get wallet by ID (when backend supports it)
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @returns Promise resolving to wallet details
+     */
+    static getWallet(authToken: string, walletId: string): Promise<any>;
+    /**
+     * Create new wallet (when backend supports it)
+     * @param authToken - Authentication token
+     * @param walletConfig - Wallet configuration
+     * @returns Promise resolving to wallet creation result
+     */
+    static createWallet(authToken: string, walletConfig: any): Promise<any>;
+}
+
+/**
+ * Signing service for cryptographic operations
+ * Handles hash signing and typed data signing with WebAuthn
+ * Uses constructor-based dependency injection for WebAuthn provider
+ */
+declare class SigningService {
+    private webAuthnProvider;
+    constructor(webAuthnProvider: WebAuthnProvider);
+    /**
+     * Sign a hash using the specified wallet
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param hash - Hash to sign
+     * @returns Promise resolving to signature response
+     */
+    signHash(authToken: string, walletId: string, hash: string): Promise<SignResponse>;
+    /**
+     * Sign EIP-712 typed data using the specified wallet
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param domain - EIP-712 domain
+     * @param types - EIP-712 types definition
+     * @param value - Data to sign
+     * @returns Promise resolving to signature response
+     */
+    signTypedData(authToken: string, walletId: string, domain: any, types: Record<string, any[]>, value: Record<string, any>): Promise<SignResponse>;
+    /**
+     * Generic signing method that handles the complete signing flow
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param request - Signing request object
+     * @returns Promise resolving to signature response
+     */
+    private signRequest;
+    /**
+     * Sign multiple requests in batch (when backend supports it)
+     * @param authToken - Authentication token
+     * @param walletId - Wallet identifier
+     * @param requests - Array of signing requests
+     * @returns Promise resolving to array of signature responses
+     */
+    signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<SignResponse[]>;
+}
+
+/**
+ * Service for interacting with PERS (Phygital Experience Rewards System) backend API
+ */
+/**
+ * Configuration interface for PERS API
+ */
+interface PersApiConfig {
+    baseUrl: string;
+    projectKey?: string;
+}
+declare class PersService {
+    private static config;
+    private static tenantCache;
+    private static currentProjectKey;
+    private static useStaging;
+    /**
+     * Configure the PERS API settings
+     * @param config - The configuration object
+     */
+    static configure(config: Partial<PersApiConfig>): void;
+    /**
+     * Enable staging mode when project key is not available
+     * @param enableStaging Whether to use staging environment
+     */
+    static setStagingMode(enableStaging: boolean): void;
+    /**
+     * Get current configuration
+     */
+    static getConfig(): PersApiConfig;
+    /**
+     * Get tenant information by tenant ID
+     * @param tenantId - The tenant ID to retrieve
+     * @param authToken - Optional auth token for authentication
+     * @returns Promise with tenant public information
+     */
+    static getTenantById(tenantId: string, authToken?: string): Promise<TenantPublicDTO>;
+    /**
+     * Initialize tenant configuration from JWT
+     * @param tenantId - The tenant ID from JWT payload
+     * @param authToken - Optional auth token for authentication
+     * @returns Promise with tenant information
+     */
+    static initializeTenant(tenantId: string, authToken?: string): Promise<TenantPublicDTO>;
+    /**
+     * Get the current project key (either from tenant or fallback)
+     * @returns The project key to use for API calls
+     */
+    private static getProjectKey;
+    /**
+     * Get cached tenant data (platform-agnostic)
+     */
+    private static getTenantFromStorage;
+    /**
+     * Store tenant data (platform-agnostic)
+     */
+    private static storeTenantInStorage;
+    /**
+     * Clear tenant cache and reset project key
+     */
+    static clearTenantCache(): void;
+    /**
+     * Authenticates a user with the PERS backend using their auth token
+     *
+     * @param authToken - The authentication token received from DFNS after login/registration
+     * @returns A promise that resolves to the authentication response
+     * @throws If the request fails
+     */
+    static authenticateUser(authToken: string): Promise<SessionAuthContextResponseDTO>;
+    /**
+     * Prepares a transaction by calling the backend endpoint
+     *
+     * @param form - The transaction details
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @returns A promise that resolves to the transaction preparation response
+     * @throws If the request fails
+     */
+    static prepareTransaction(form: any, persAccessToken: string): Promise<TransactionRequestResponseDTO>;
+    /**
+     * Submits a transaction by calling the backend endpoint
+     *
+     * @param transactionId - The ID of the transaction to submit
+     * @param signedTransactionOrSignature - The signed transaction data or EIP-712 signature
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @param submissionType - The transaction format type
+     * @returns A promise that resolves to the transaction submission response
+     * @throws If the request fails
+     */
+    static submitTransaction(transactionId: string, signedTransactionOrSignature: string, persAccessToken: string, submissionType: TransactionFormat): Promise<any>;
+    /**
+     * Fetches a prepared transaction for signing by transactionId
+     * @param transactionId - The transaction ID to fetch
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @returns The prepared transaction data
+     * @throws If the request fails
+     */
+    static fetchPreparedTransaction(transactionId: string, persAccessToken: string): Promise<TransactionRequestResponseDTO>;
+    /**
+     * Claims a reward from the PERS blockchain system
+     * @param rewardId - The ID of the reward to claim
+     * @param pointsCost - The points cost for the reward
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @returns The reward claim response including reward image URL
+     * @throws If the request fails
+     */
+    static claimReward(rewardId: string, pointsCost: number, persAccessToken: string): Promise<any>;
+    /**
+     * Get all active campaigns
+     * @returns Promise with list of active campaigns
+     */
+    static getActiveCampaigns(): Promise<CampaignDTO[]>;
+    /**
+     * Claims a campaign for a user
+     * @param campaignId - The ID of the campaign to claim
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @returns Promise with the campaign claim response
+     * @throws If the request fails
+     */
+    static claimCampaign(campaignId: string, persAccessToken: string): Promise<CampaignClaimDTO>;
+    /**
+     * Gets all campaign claims for the authenticated user
+     * @param persAccessToken - The PERS access token for authentication (Bearer)
+     * @returns Promise with list of user's campaign claims
+     * @throws If the request fails
+     */
+    static getUserCampaignClaims(persAccessToken: string): Promise<CampaignClaimDTO[]>;
+    /**
+     * Gets all available rewards for redemption
+     * @returns Promise with list of available rewards that can be exchanged for points
+     * @throws If the request fails
+     */
+    static getAvailableRedemptions(): Promise<any[]>;
+    /**
+     * Helper method to determine if transaction data is available for signing
+     * @param transactionResponse - Response from prepare or fetch transaction
+     * @returns boolean indicating if transaction can be signed
+     */
+    static isTransactionReadyForSigning(transactionResponse: TransactionRequestResponseDTO): boolean;
+    /**
+     * Helper method to get transaction data from response
+     * @param transactionResponse - Response from prepare or fetch transaction
+     * @returns The transaction data ready for signing
+     * @throws If transaction data is not available
+     */
+    static getTransactionDataForSigning(transactionResponse: TransactionRequestResponseDTO): _explorins_pers_shared_browser.CounterfactualWalletTransactionResponse | _explorins_web3_ts_types.LegacyTransaction;
+}
+
+/**
+ * Shared type definitions for the blockchain signer shared library
+ */
+
+/**
+ * Represents a wallet configuration with its metadata
+ */
+interface WalletConfig {
+    id: string;
+    name: string;
+    address?: string;
+    credentialId?: string;
+    publicKey?: string;
+    createdAt?: Date;
+}
+/**
+ * Authentication token structure
+ */
+interface AuthToken {
+    token: string;
+    expiresAt: Date;
+    refreshToken?: string;
+}
+/**
+ * User authentication state
+ */
+interface AuthState {
+    isAuthenticated: boolean;
+    token?: AuthToken;
+    user?: UserProfile;
+    wallets?: WalletConfig[];
+}
+/**
+ * User profile information
+ */
+interface UserProfile {
+    id: string;
+    username: string;
+    email?: string;
+    createdAt: Date;
+    lastLoginAt?: Date;
+}
+/**
+ * Prepared transaction from PERS service
+ */
+interface PreparedTransaction {
+    id: string;
+    transactionData: AnyTransactionData;
+    metadata?: Record<string, any>;
+    createdAt: Date;
+    expiresAt?: Date;
+}
+/**
+ * Transaction signing result
+ */
+interface SigningResult$1 {
+    signature: string;
+    transactionHash?: string;
+    rawTransaction?: string;
+}
+/**
+ * Environment variable types for shared services
+ */
+interface SharedLibEnvironment {
+}
+/**
+ * Service configuration options
+ */
+interface ServiceConfig$1 {
+    apiUrl: string;
+    environment: 'development' | 'staging' | 'production';
+    timeout?: number;
+    retryAttempts?: number;
+}
+/**
+ * Error types for service operations
+ */
+interface ServiceError {
+    code: string;
+    message: string;
+    details?: any;
+    timestamp: Date;
+}
+/**
+ * API response wrapper
+ */
+interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: ServiceError;
+    metadata?: Record<string, any>;
+}
+
+interface GetWalletResponse {
+    id: string;
+    signingKey: {
+        publicKey: string;
+    };
+}
+
+type WalletOptions = {
+    wallet: WalletMetadata;
+    authToken: string;
+    signingService: SigningService;
+};
+type WalletMetadata = GetWalletResponse & {
+    boundToEvmNetwork: boolean;
+};
+declare class KeyWallet extends AbstractSigner {
+    private options;
+    private address?;
+    private authToken;
+    private metadata;
+    private signingService;
+    constructor(options: WalletOptions, provider?: Provider | null);
+    connect(provider: Provider | null): KeyWallet;
+    getAddress(): Promise<string>;
+    private signHash;
+    signTransaction(tx: TransactionRequest): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
+    /**
+     * Signs a PERS transaction based on its format
+     * Handles different transaction types: Legacy, EIP-2930, EIP-1559, and EIP-712
+     * @param transactionData - The transaction data from PERS API
+     * @returns The signature string
+     */
+    signPersTransaction(transactionData: AnyTransactionData): Promise<string>;
+}
+
+/**
+ * Combined transaction status type that includes both PERS and additional statuses
+ */
+type CombinedTransactionStatus = TransactionStatus;
+/**
+ * Transaction statuses that allow signing
+ */
+declare const SIGNABLE_STATUSES: readonly [TransactionStatus.PENDING_SIGNATURE, TransactionStatus.CREATED];
+/**
+ * Transaction status information for UI display
+ */
+interface TransactionStatusInfo {
+    transactionId: string;
+    transactionStatus: CombinedTransactionStatus;
+    message: string;
+}
+/**
+ * Transaction signing result
+ */
+interface TransactionSigningResult {
+    success: boolean;
+    transactionId: string;
+    transactionHash?: string;
+    signature?: string;
+    error?: string;
+    statusInfo?: TransactionStatusInfo;
+    shouldRedirect?: boolean;
+    redirectUrl?: string;
+    shouldShowStatus?: boolean;
+}
+/**
+ * Transaction result for localStorage storage
+ */
+interface StoredTransactionResult {
+    transactionId: string;
+    transactionHash: string;
+}
+/**
+ * Transaction submission result for internal processing
+ */
+interface SubmissionResult {
+    submitResult: TransactionRequestResponseDTO;
+    shouldRedirect: boolean;
+    redirectUrl?: string;
+}
+/**
+ * Metadata for transaction parameters - string values only
+ */
+interface TransactionMetadata {
+    [key: string]: string;
+}
+/**
+ * Authentication tokens required for transaction signing
+ */
+interface SigningAuthTokens {
+    backendAuthToken: string;
+    persAccessToken: string;
+}
+/**
+ * Transaction signing parameters
+ */
+interface TransactionSigningParams {
+    transactionId: string;
+    authTokens: SigningAuthTokens;
+    ethersProviderUrl: string;
+    returnUrl?: string;
+    metadata?: TransactionMetadata;
+    walletRegistrationFailed?: boolean;
+    walletErrorDetails?: string;
+}
+
+/**
+ * Service for orchestrating transaction signing operations
+ * Handles the complete flow from transaction preparation to submission
+ * Uses constructor-based dependency injection for WebAuthn provider
+ */
+declare class TransactionSigningService {
+    private webAuthnProvider;
+    constructor(webAuthnProvider: WebAuthnProvider);
+    /**
+     * Prepare transaction for signing - fetch and validate
+     */
+    private prepareTransaction;
+    /**
+     * Validate and prepare wallet for signing
+     */
+    private prepareWallet;
+    /**
+     * Execute the transaction signing with WebAuthn coordination
+     */
+    private executeTransactionSigning;
+    /**
+     * Main transaction signing orchestration method
+     * Handles the complete flow from preparation to submission
+     * @param params - Transaction signing parameters
+     * @returns Promise resolving to transaction signing result
+     * @throws TransactionSigningError for validation and operation failures
+     */
+    signTransaction(params: TransactionSigningParams): Promise<TransactionSigningResult>;
+}
+
+/**
+ * Error codes for transaction signing operations
+ */
+declare enum TransactionSigningErrorCode {
+    INVALID_TOKENS = "INVALID_TOKENS",
+    TRANSACTION_NOT_FOUND = "TRANSACTION_NOT_FOUND",
+    TRANSACTION_NOT_PENDING = "TRANSACTION_NOT_PENDING",
+    WALLET_NOT_AVAILABLE = "WALLET_NOT_AVAILABLE",
+    WEBAUTHN_OPERATION_IN_PROGRESS = "WEBAUTHN_OPERATION_IN_PROGRESS",
+    SIGNING_CANCELLED = "SIGNING_CANCELLED",
+    PERS_AUTH_FAILED = "PERS_AUTH_FAILED",
+    AUTH_FAILED = "AUTH_FAILED",
+    TRANSACTION_NOT_READY = "TRANSACTION_NOT_READY",
+    SUBMISSION_FAILED = "SUBMISSION_FAILED",
+    SERVER_ERROR = "SERVER_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * Structured error for transaction signing operations
+ */
+interface TransactionSigningError extends Error {
+    code: TransactionSigningErrorCode;
+    transactionId?: string;
+    originalError?: unknown;
+}
+
+/**
+ * Handles all error-related operations for transaction signing
+ */
+declare class TransactionErrorHandler {
+    /**
+     * Get user-friendly status messages for transaction statuses
+     * @param status - The transaction status
+     * @returns Human-readable message explaining the status
+     */
+    static getStatusMessage(status: CombinedTransactionStatus): string;
+    /**
+     * Safely convert string status to TransactionStatus enum
+     * @param statusString - The status string to convert
+     * @returns A valid TransactionStatus enum value
+     */
+    static parseTransactionStatus(statusString: string): CombinedTransactionStatus;
+    /**
+     * Create a structured transaction signing error
+     * @param code - Error code
+     * @param message - Error message
+     * @param transactionId - Optional transaction ID
+     * @param originalError - Original error that caused this
+     * @returns Structured error object
+     */
+    static createError(code: TransactionSigningErrorCode, message: string, transactionId?: string, originalError?: unknown): TransactionSigningError;
+    /**
+     * Create transaction status info object for UI display
+     * @param transactionId - The transaction ID
+     * @param status - The transaction status
+     * @param customMessage - Optional custom message, otherwise uses default status message
+     * @returns TransactionStatusInfo object
+     */
+    static createStatusInfo(transactionId: string, status: CombinedTransactionStatus, customMessage?: string): TransactionStatusInfo;
+    /**
+     * Handle TRANSACTION_NOT_PENDING error from PERS API
+     * Consolidates the duplicate error handling logic
+     * @param error - The error object from PERS API
+     * @param transactionId - The transaction ID
+     * @returns Never (always throws)
+     * @throws Object with shouldShowStatus and statusInfo
+     */
+    static handleTransactionNotPendingError(error: {
+        status?: number;
+        error?: {
+            code?: string;
+            message?: string;
+            developerMessage?: string;
+        };
+        code?: string;
+        message?: string;
+        developerMessage?: string;
+    }, transactionId: string): never;
+    /**
+     * Process PERS API errors and handle TRANSACTION_NOT_PENDING cases
+     * @param err - The caught error from PERS API
+     * @param transactionId - The transaction ID
+     * @throws Either the original error or a structured status error
+     */
+    static processPersApiError(err: unknown, transactionId: string): never;
+}
+
+/**
+ * Handles all validation operations for transaction signing
+ */
+declare class TransactionValidator {
+    /**
+     * Validate transaction signing parameters
+     * @param params - Transaction signing parameters to validate
+     * @throws TransactionSigningError if validation fails
+     */
+    static validateSigningParams(params: TransactionSigningParams): void;
+    /**
+     * Validate authentication tokens passed as parameters
+     * @param authTokens - The authentication tokens to validate
+     * @returns true if valid, throws error if invalid
+     */
+    static validateAuthTokens(authTokens: SigningAuthTokens): boolean;
+}
+
+/**
+ * Handles transaction submission, success flows, and redirect logic
+ */
+declare class TransactionSubmissionHandler {
+    /**
+     * Create redirect URL with transaction parameters
+     * @param returnUrl - Base return URL
+     * @param transactionHash - Transaction hash to include
+     * @param metadata - Optional metadata to include as parameters
+     * @returns Promise resolving to the complete redirect URL
+     */
+    static createRedirectUrl(returnUrl: string, transactionHash: string, metadata?: TransactionMetadata): Promise<string>;
+    /**
+     * Submit transaction and handle success flow
+     * @param preparedTransaction - The prepared transaction
+     * @param signature - The transaction signature
+     * @param signingData - The signing data used
+     * @param authTokens - Authentication tokens
+     * @param transactionId - Transaction ID for tracking
+     * @param returnUrl - Optional return URL for redirect
+     * @param metadata - Optional metadata for redirect parameters
+     * @returns Promise resolving to submission result
+     */
+    static handleTransactionSubmission(preparedTransaction: TransactionRequestResponseDTO, signature: string, signingData: AnyTransactionData, authTokens: SigningAuthTokens, returnUrl?: string, metadata?: TransactionMetadata): Promise<SubmissionResult>;
+}
+
+/**
+ * Utility class for coordinating WebAuthn operations to prevent conflicts
+ * Manages global state flags to ensure only one WebAuthn operation runs at a time
+ */
+declare class WebAuthnCoordinator {
+    /**
+     * Clear the landing authentication flag
+     * Used when starting a new transaction signing flow
+     */
+    static clearLandingAuthentication(): void;
+    /**
+     * Check if a WebAuthn operation is currently in progress
+     * @returns True if an operation is in progress, false otherwise
+     */
+    static checkConcurrentOperations(): boolean;
+    /**
+     * Set the WebAuthn operation in progress flag
+     * @param inProgress - Whether an operation is in progress
+     */
+    static setOperationInProgress(inProgress: boolean): void;
+}
+
+/**
+ * Platform-agnostic configuration provider
+ * Abstracts environment variable access for cross-platform compatibility
+ */
+interface ServiceConfig {
+    apiUrl: string;
+    appId?: string;
+    relyingParty: {
+        id: string;
+        name: string;
+        origin?: string;
+    };
+}
+interface ConfigProvider {
+    getServiceConfig(): ServiceConfig;
+}
+/**
+ * Web platform configuration provider
+ * Uses provided configuration instead of environment variables
+ */
+declare class WebConfigProvider implements ConfigProvider {
+    private config;
+    constructor(config: ServiceConfig);
+    getServiceConfig(): ServiceConfig;
+}
+/**
+ * React Native configuration provider
+ * Uses process.env or custom config for React Native environments
+ */
+declare class ReactNativeConfigProvider implements ConfigProvider {
+    private config;
+    constructor(config: ServiceConfig);
+    getServiceConfig(): ServiceConfig;
+}
+/**
+ * Static configuration provider for testing or custom setups
+ */
+declare class StaticConfigProvider implements ConfigProvider {
+    private config;
+    constructor(config: ServiceConfig);
+    getServiceConfig(): ServiceConfig;
+}
+/**
+ * Set the global configuration provider
+ */
+declare function setConfigProvider(provider: ConfigProvider): void;
+/**
+ * Get the current configuration provider
+ * Requires explicit initialization with setConfigProvider
+ */
+declare function getConfigProvider(): ConfigProvider;
+/**
+ * Get the service configuration
+ */
+declare function getServiceConfig(): ServiceConfig;
+
+/**
+ * Platform-agnostic HTTP client abstraction
+ * Provides a consistent interface for HTTP requests across platforms
+ */
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+interface HttpRequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: any;
+    timeout?: number;
+}
+interface HttpClient {
+    request<T = any>(url: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
+    get<T = any>(url: string, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+    post<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+    put<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+    delete<T = any>(url: string, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+}
+/**
+ * Fetch-based HTTP client for web environments
+ */
+declare class FetchHttpClient implements HttpClient {
+    private defaultHeaders;
+    request<T = any>(url: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
+    get<T = any>(url: string, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+    post<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+    put<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+    delete<T = any>(url: string, headers?: Record<string, string>): Promise<HttpResponse<T>>;
+}
+/**
+ * Set the global HTTP client
+ */
+declare function setHttpClient(client: HttpClient): void;
+/**
+ * Get the current HTTP client
+ */
+declare function getHttpClient(): HttpClient;
+
+/**
+ * Browser-specific WebAuthn provider using DFNS browser SDK
+ */
+
+/**
+ * Get WebAuthn provider for browser environments
+ */
+declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
+
+/**
+ * React Native-specific WebAuthn provider using DFNS React Native SDK
+ * Falls back to browser implementation for React Native Web (Expo Web)
+ */
+
+/**
+ * Get WebAuthn provider for React Native environments
+ */
+declare function getReactNativeWebAuthnProvider(): Promise<WebAuthnProvider>;
+
+/**
+ * PERS Blockchain Signer SDK - Simple Orchestrator
+ *
+ * Lightweight SDK that orchestrates existing services.
+ * Uses environment configuration and existing infrastructure.
+ */
+
+interface JWTPayload {
+    email?: string;
+    userId?: string;
+    tenantId?: string;
+    exp?: number;
+    [key: string]: any;
+}
+interface PersAuthResult {
+    user: {
+        email?: string;
+        id?: string;
+    };
+    accessToken: string;
+}
+/**
+ * User information for authentication
+ */
+interface SignerUserInfo {
+    identifier: string;
+    email?: string;
+    id?: string;
+}
+/**
+ * Authenticated user with all required tokens
+ */
+interface SignerAuthenticatedUser {
+    identifier: string;
+    signerAuthToken: string;
+    persAccessToken: string;
+}
+interface AuthenticationResult {
+    user: SignerAuthenticatedUser;
+    isExpired: boolean;
+}
+interface JWTExtractionResult {
+    payload: JWTPayload | null;
+    isExpired: boolean;
+}
+interface PersSignerConfig {
+    tenantId?: string;
+    ethersProviderUrl?: string;
+    webAuthnProvider: WebAuthnProvider;
+    apiUrl?: string;
+    relyingPartyName?: string;
+}
+interface SigningResult {
+    success: boolean;
+    transactionHash?: string;
+    error?: string;
+}
+/**
+ * Main PERS Signer SDK class
+ *
+ * Simple orchestrator that uses existing services and environment configuration.
+ * No complex initialization needed - services are already configured.
+ */
+declare class PersSignerSDK {
+    private config;
+    private authService;
+    private signingService;
+    private transactionSigningService;
+    private webAuthnProvider;
+    constructor(config: PersSignerConfig);
+    /**
+     * Re-export TransactionSigningService with WebAuthn provider already injected
+     * This provides the same interface as the original service but with automatic provider injection
+     */
+    get TransactionSigningService(): TransactionSigningService;
+    /**
+     * Complete user onboarding flow - same as web project
+     * Uses existing AuthenticationService and PersService
+     */
+    authenticateUser(userInfo: SignerUserInfo): Promise<SignerAuthenticatedUser>;
+    /**
+     * Complete PERS transaction signing flow - exactly like web project
+     * Uses existing TransactionSigningService with injected WebAuthn provider
+     */
+    signPersTransaction(user: SignerAuthenticatedUser, transactionId: string): Promise<SigningResult>;
+    /**
+     * Register new user - uses existing AuthenticationService
+     */
+    registerUser(identifier: string): Promise<{
+        authToken: string;
+    }>;
+    /**
+     * Login existing user - uses existing AuthenticationService
+     */
+    loginUser(identifier: string): Promise<string>;
+    /**
+     * Add wallet to PERS user - uses existing PersService
+     */
+    addWalletToPersUser(signerAuthToken: string): Promise<string>;
+    /**
+     * Retrieve transaction data from PERS - uses existing PersService
+     */
+    retrieveTransactionData(transactionId: string, persAccessToken: string): Promise<TransactionRequestResponseDTO>;
+    /**
+     * Sign transaction data - uses existing SigningService
+     * Follows same patterns as KeyWallet.signPersTransaction
+     */
+    signTransactionData(signerAuthToken: string, signingData: AnyTransactionData): Promise<string>;
+    /**
+     * Submit signed transaction to PERS - uses existing PersService
+     */
+    submitTransaction(transactionId: string, signature: string, persAccessToken: string, transactionFormat?: TransactionFormat): Promise<{
+        transactionHash?: string;
+        success: boolean;
+    }>;
+    /**
+     * Check if user exists - uses existing AuthenticationService
+     */
+    checkUserExists(identifier: string): Promise<boolean>;
+    /**
+     * Get user wallets - uses existing WalletService
+     */
+    getUserWallets(signerAuthToken: string): Promise<any>;
+    /**
+     * Get transaction status - uses existing PersService
+     */
+    getTransactionStatus(transactionId: string, persAccessToken: string): Promise<{
+        status: string;
+        transactionHash?: string;
+    }>;
+    /**
+     * Initialize tenant - uses existing PersService
+     */
+    initializeTenant(tenantId: string): Promise<void>;
+    /**
+     * Extract and validate JWT token from URL search parameters
+     * Uses a simpler approach compatible with browser environments
+     */
+    extractJWTFromURL(searchParams: URLSearchParams): JWTExtractionResult;
+    /**
+     * Initialize tenant from JWT payload using existing PersService
+     */
+    initializeTenantFromJWT(payload: JWTPayload): Promise<string>;
+    /**
+     * Authenticate user with PERS API using existing PersService pattern
+     */
+    /**
+     * Authenticate user with PERS API using existing PersService
+     */
+    authenticatePersUser(jwtToken: string, projectKey: string): Promise<PersAuthResult>;
+    /**
+     * Combined PERS + DFNS authentication flow
+     */
+    combinedAuthentication(identifier: string, persAccessToken: string): Promise<SignerAuthenticatedUser>;
+    /**
+     * Complete JWT-based authentication flow (legacy PERS flow)
+     */
+    authenticateWithJWT(searchParams: URLSearchParams): Promise<AuthenticationResult | null>;
+}
+/**
+ * Factory function to create SDK
+ * Requires WebAuthnProvider from platform-specific entry point
+ */
+declare function createPersSignerSDK(config: PersSignerConfig): PersSignerSDK;
+
+/**
+ * Wallet list response from WalletService
+ */
+interface WalletListResponse {
+    items: WalletItem[];
+}
+/**
+ * Individual wallet item from wallet list - compatible with KeyWallet constructor
+ */
+interface WalletItem {
+    id: string;
+    address: string;
+    network: string;
+    status: string;
+    signingKey?: unknown;
+    dateCreated?: string;
+    custodial?: boolean;
+    tags?: string[];
+    boundToEvmNetwork?: boolean;
+    [key: string]: unknown;
+}
+
+/**
+ * Utility functions for handling URL search parameters in a consistent way across applications
+ */
+/**
+ * Creates a URL search string that preserves all current parameters
+ * @param paramsToExclude Array of parameter names to exclude from the result
+ * @param paramsToAdd Object with additional parameters to add or override
+ * @param baseParams Optional URLSearchParams object to use instead of window.location.search
+ * @returns A search string with '?' prefix if there are parameters, or empty string if no parameters
+ */
+declare function createSearchString(paramsToExclude?: string[], paramsToAdd?: Record<string, string>, baseParams?: URLSearchParams | string): string;
+/**
+ * Creates a URL path with search parameters
+ * @param basePath The base path without search parameters
+ * @param paramsToExclude Array of parameter names to exclude from the result
+ * @param paramsToAdd Object with additional parameters to add or override
+ * @param baseParams Optional URLSearchParams object to use instead of window.location.search
+ * @returns A full path with search parameters
+ */
+declare function createUrlWithSearchParams(basePath: string, paramsToExclude?: string[], paramsToAdd?: Record<string, string>, baseParams?: URLSearchParams | string): string;
+/**
+ * Combines the current search parameters with new ones
+ * @param searchParams The current URLSearchParams object
+ * @param additionalParams Object with parameters to add or update
+ * @returns A new URLSearchParams object
+ */
+declare function mergeSearchParams(searchParams: URLSearchParams, additionalParams?: Record<string, string>): URLSearchParams;
+/**
+ * Gets a specific search parameter value
+ * @param key The parameter name to get
+ * @param search Optional search string to parse (defaults to window.location.search)
+ * @returns The parameter value or null if not found
+ */
+declare function getSearchParam(key: string, search?: string): string | null;
+/**
+ * Gets all search parameters as a URLSearchParams object
+ * @param search Optional search string to parse (defaults to window.location.search)
+ * @returns A URLSearchParams object
+ */
+declare function getAllSearchParams(search?: string): URLSearchParams;
+/**
+ * Removes a specific search parameter
+ * @param key The parameter name to remove
+ * @param search Optional search string to parse (defaults to window.location.search)
+ * @returns A new search string without the specified parameter
+ */
+declare function removeSearchParam(key: string, search?: string): string;
+/**
+ * Updates or adds a specific search parameter
+ * @param key The parameter name to update
+ * @param value The new value for the parameter
+ * @param search Optional search string to parse (defaults to window.location.search)
+ * @returns A new search string with the updated parameter
+ */
+declare function updateSearchParam(key: string, value: string, search?: string): string;
+
+/**
+ * Utility for debugging search parameter handling
+ */
+/**
+ * Logs the current search parameters with a custom message
+ * This is useful for debugging search parameter preservation across navigation
+ *
+ * @param message - A descriptive message to identify where the logging happens
+ * @param additionalData - Optional additional data to log
+ */
+declare function logSearchParams(message: string, additionalData?: any): void;
+/**
+ * Creates a search parameter tracking hook that can be used in React components
+ * Logs search parameter changes when the component mounts/updates
+ *
+ * @param componentName - The name of the component (for logging)
+ */
+declare function createSearchParamLogger(componentName: string): () => void;
+
+/**
+ * Generates a RFC4122 version 4 compliant UUID
+ * @returns A randomly generated UUID
+ */
+declare function generateUUID(): string;
+/**
+ * Create a semi-anonymous username for users
+ * @returns A username in the format "user_[random string]"
+ */
+declare function generateAnonymousUsername(): string;
+/**
+ * Create a guest username for the application with a random prefix
+ * @returns A guest email in the format "randomstring_guest@explorins.com"
+ */
+declare function generateGuestUsername(): string;
+
+/**
+ * Utility functions for tenant-specific operations
+ */
+/**
+ * Represents a tenant configuration
+ */
+interface TenantConfig {
+    id: string;
+    name: string;
+    analytics?: {
+        enabled: boolean;
+        trackingId?: string;
+    };
+}
+/**
+ * Initialize tenant-specific analytics
+ * @param tenantId The tenant ID
+ * @param getTenantConfig Function to retrieve tenant configuration
+ */
+declare const initTenantAnalytics: (tenantId: string, getTenantConfig: (id: string) => TenantConfig | null) => void;
+
+export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, createSearchParamLogger, createSearchString, createUrlWithSearchParams, generateAnonymousUsername, generateGuestUsername, generateUUID, getAllSearchParams, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getReactNativeWebAuthnProvider, getSearchParam, getServiceConfig, initTenantAnalytics, logSearchParams, mergeSearchParams, removeSearchParam, setConfigProvider, setHttpClient, updateSearchParam };
+export type { ApiResponse, AuthResponse, AuthState, AuthToken, AuthenticationResult, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, JWTExtractionResult, JWTPayload, WalletItem$1 as KeyWalletItem, WalletListResponse$1 as KeyWalletListResponse, PersAuthResult, PersSignerConfig, PreparedTransaction, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig$1 as ServiceConfig, ServiceError, SharedLibEnvironment, SignResponse, SignerAuthenticatedUser, SignerUserInfo, SigningAuthTokens, SigningChallenge, SigningRequest, SigningResult$1 as SigningResult, StoredTransactionResult, SubmissionResult, TenantConfig, TransactionMetadata, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, UserProfile, WalletConfig, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };