@explorins/pers-signer 1.0.17 → 1.0.18

package/dist/browser.d.ts

@@ -1,9 +1,9 @@
 import * as _explorins_web3_ts_types from '@explorins/web3-ts/types';
-import { AnyTransactionData, LegacyTransaction } from '@explorins/web3-ts/types';
-export { AnyTransactionData } from '@explorins/web3-ts/types';
+import { LegacyTransaction, AnyTransactionData } from '@explorins/web3-ts/types';
+export { AnyTransactionData, BaseTransaction, CounterfactualWalletEIP712Data, EIP1559Transaction, EIP2930Transaction, EIP712TransactionData, EIP712TypedData, LegacyTransaction } from '@explorins/web3-ts/types';
 import * as _explorins_pers_shared_browser from '@explorins/pers-shared/browser';
 import { TenantPublicDTO, SessionAuthContextResponseDTO, TransactionFormat, TransactionRequestResponseDTO, CounterfactualWalletTransactionResponse, TransactionStatus } from '@explorins/pers-shared/browser';
-export { TransactionFormat, TransactionRequestResponseDTO, TransactionStatus } from '@explorins/pers-shared/browser';
+export { CampaignClaimDTO, CampaignDTO, SessionAuthResponseDTO, TRANSACTION_FORMATS, TRANSACTION_FORMAT_DESCRIPTIONS, TransactionFormat, TransactionRequestResponseDTO, TransactionStatus, TransactionSubmissionRequestDTO } from '@explorins/pers-shared/browser';
 import { AbstractSigner, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
 import { CounterfactualWalletTransactionResponse as CounterfactualWalletTransactionResponse$1 } from '@explorins/pers-shared';
 
@@ -249,6 +249,29 @@ interface RelyingPartyConfig {
     origin?: string;
 }
 
+/**
+ * Type definitions for the new PERS Signer API v1
+ * Based on API_MIGRATION_REFERENCE.md - Updated for wrapped responses
+ */
+interface SignerApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+}
+interface SignerApiError {
+    status: number;
+    error: string;
+    message: string;
+    request_id: string;
+    timestamp: string;
+    suggestion?: {
+        action: string;
+        text: string;
+        endpoint: string;
+    };
+}
+interface LoginRequest {
+    authToken: string;
+}
 interface JWTLoginResponse {
     success: true;
     access_token: string;
@@ -261,6 +284,14 @@ interface JWTLoginResponse {
     };
     provider: string;
 }
+interface WrappedProviderResponse {
+    success: true;
+    data: unknown;
+}
+type LoginResponse = JWTLoginResponse | WrappedProviderResponse;
+interface VerifyTokenRequest {
+    token: string;
+}
 interface VerifyTokenResponse {
     valid: boolean;
     provider: string;
@@ -278,6 +309,45 @@ interface VerifyTokenResponse {
     };
     tenantId: string;
 }
+interface InitRegistrationRequest {
+    authToken: string;
+}
+interface InitRegistrationResponse {
+    success: true;
+    data: {
+        challenge?: string;
+        temporaryAuthenticationToken?: string;
+        user?: object;
+        [key: string]: unknown;
+    };
+}
+type CompleteRegistrationResponse = JWTLoginResponse | WrappedProviderResponse;
+interface ListWalletsRequest {
+}
+interface ListWalletsResponse {
+    success: true;
+    data: {
+        wallets?: Array<unknown>;
+        [key: string]: unknown;
+    };
+}
+interface InitSignatureRequest {
+    walletId: string;
+    request: unknown;
+}
+interface InitSignatureResponse {
+    success: true;
+    data: {
+        requestBody: unknown;
+        challenge: unknown;
+        [key: string]: unknown;
+    };
+}
+interface CompleteSignatureRequest {
+    walletId: string;
+    requestBody: unknown;
+    signedChallenge: unknown;
+}
 interface CompleteSignatureResponse {
     success: true;
     data: {
@@ -304,6 +374,9 @@ interface CompleteSignatureResponse {
         [key: string]: unknown;
     };
 }
+interface HealthCheckResponse {
+    success: boolean;
+}
 
 /**
  * Signing service for cryptographic operations
@@ -349,76 +422,6 @@ declare class SigningService {
     signBatch(authToken: string, walletId: string, requests: SigningRequest[]): Promise<CompleteSignatureResponse['data'][]>;
 }
 
-/**
- * Shared type definitions for the blockchain signer shared library
- */
-
-/**
- * Authentication types for 3-function split architecture
- */
-interface AuthenticatedUser {
-    identifier: string;
-    signerAuthToken: string;
-    persAccessToken: string;
-    tenantId: string;
-    expiresAt: number;
-}
-/**
- * Service configuration options
- */
-interface ServiceConfig {
-    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;
-}
-
-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
  */
@@ -479,6 +482,115 @@ interface TransactionSigningParams {
     returnUrl?: string;
 }
 
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Central type definitions for the blockchain signer shared library
+ * Single source of truth for all type exports
+ */
+
+/**
+ * Authentication types for 3-function split architecture
+ */
+interface AuthenticatedUser {
+    identifier: string;
+    signerAuthToken: string;
+    persAccessToken: string;
+    expiresAt: number;
+}
+/**
+ * Error types for service operations
+ */
+interface ServiceError {
+    code: string;
+    message: string;
+    details?: any;
+    timestamp: Date;
+}
+
+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>;
+}
+
 /**
  * PERS Blockchain Signer SDK
  *
@@ -715,32 +827,6 @@ declare class TransactionSigningService {
     signTransaction(params: TransactionSigningParams, signingData: CounterfactualWalletTransactionResponse | LegacyTransaction): 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
  */
@@ -950,36 +1036,6 @@ declare function setHttpClient(client: HttpClient): void;
  */
 declare function getHttpClient(): HttpClient;
 
-/**
- * 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;
-}
-
-/**
- * Authenticated user with all required tokens
- */
-interface SignerAuthenticatedUser {
-    identifier: string;
-    signerAuthToken: string;
-    persAccessToken: string;
-}
 /**
  * Authentication service for user login and registration
  * Uses constructor-based dependency injection for WebAuthn provider
@@ -1034,7 +1090,7 @@ declare class AuthenticationService {
      * @param relyingPartyConfig - Configuration for WebAuthn relying party
      * @returns Promise resolving to authenticated user with signer token
      */
-    combinedAuthentication(identifier: string, persAccessToken: string): Promise<SignerAuthenticatedUser>;
+    combinedAuthentication(identifier: string, persAccessToken: string): Promise<AuthenticatedUser>;
 }
 
 /**
@@ -1058,4 +1114,4 @@ declare function getBrowserWebAuthnProvider(): Promise<WebAuthnProvider>;
 declare function createPersSignerSDK(config: PersSignerConfig): Promise<PersSignerSDK>;
 
 export { AuthenticationService, FetchHttpClient, KeyWallet, PersService, PersSignerSDK, ReactNativeConfigProvider, SIGNABLE_STATUSES, SigningService, StaticConfigProvider, TransactionErrorHandler, TransactionSigningErrorCode, TransactionSigningService, TransactionSubmissionHandler, TransactionValidator, WalletService, WebAuthnCoordinator, WebConfigProvider, createPersSignerSDK, getBrowserWebAuthnProvider, getConfigProvider, getHttpClient, getServiceConfig, getBrowserWebAuthnProvider as getWebAuthnProvider, setConfigProvider, setHttpClient };
-export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, ConfigProvider, HashSigningRequest, HttpClient, HttpRequestOptions, HttpResponse, PersSignerConfig, PlatformConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceConfig, ServiceError, SignResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };
+export type { AuthResponse, AuthenticatedUser, CombinedTransactionStatus, CompleteRegistrationResponse, CompleteSignatureRequest, CompleteSignatureResponse, ConfigProvider, HashSigningRequest, HealthCheckResponse, HttpClient, HttpRequestOptions, HttpResponse, InitRegistrationRequest, InitRegistrationResponse, InitSignatureRequest, InitSignatureResponse, ListWalletsRequest, ListWalletsResponse, LoginRequest, LoginResponse, PersSignerConfig, PlatformConfig, RegistrationChallenge, RegistrationResult, RelyingPartyConfig, ServiceError, SignResponse, SignerApiError, SignerApiResponse, SigningAuthTokens, SigningChallenge, SigningRequest, SubmissionResult, TransactionSigningError, TransactionSigningParams, TransactionSigningResult, TransactionStatusInfo, TypedDataSigningRequest, UserCredentials, VerifyTokenRequest, VerifyTokenResponse, WalletItem, WalletListResponse, WebAuthnConfig, WebAuthnProvider };

package/dist/browser.esm.js

@@ -1,5 +1,5 @@
 import { TRANSACTION_FORMATS, TransactionStatus } from '@explorins/pers-shared/browser';
-export { TransactionStatus } from '@explorins/pers-shared/browser';
+export { TRANSACTION_FORMATS, TRANSACTION_FORMAT_DESCRIPTIONS, TransactionStatus } from '@explorins/pers-shared/browser';
 import { AbstractSigner, computeAddress, resolveProperties, resolveAddress, getAddress, Transaction, toUtf8Bytes, keccak256, Signature, JsonRpcProvider } from 'ethers';
 
 function _mergeNamespaces(n, m) {
@@ -564,6 +564,30 @@ PersService.currentTenantId = null;
 PersService.useStaging = false;
 PersService.TENANT_CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours - tenant configs are essentially static
 
+/**
+ * Transaction statuses that allow signing
+ */
+const SIGNABLE_STATUSES = [TransactionStatus.PENDING_SIGNATURE, TransactionStatus.CREATED];
+
+/**
+ * Error codes for transaction signing operations
+ */
+var TransactionSigningErrorCode;
+(function (TransactionSigningErrorCode) {
+    TransactionSigningErrorCode["INVALID_TOKENS"] = "INVALID_TOKENS";
+    TransactionSigningErrorCode["TRANSACTION_NOT_FOUND"] = "TRANSACTION_NOT_FOUND";
+    TransactionSigningErrorCode["TRANSACTION_NOT_PENDING"] = "TRANSACTION_NOT_PENDING";
+    TransactionSigningErrorCode["WALLET_NOT_AVAILABLE"] = "WALLET_NOT_AVAILABLE";
+    TransactionSigningErrorCode["WEBAUTHN_OPERATION_IN_PROGRESS"] = "WEBAUTHN_OPERATION_IN_PROGRESS";
+    TransactionSigningErrorCode["SIGNING_CANCELLED"] = "SIGNING_CANCELLED";
+    TransactionSigningErrorCode["PERS_AUTH_FAILED"] = "PERS_AUTH_FAILED";
+    TransactionSigningErrorCode["AUTH_FAILED"] = "AUTH_FAILED";
+    TransactionSigningErrorCode["TRANSACTION_NOT_READY"] = "TRANSACTION_NOT_READY";
+    TransactionSigningErrorCode["SUBMISSION_FAILED"] = "SUBMISSION_FAILED";
+    TransactionSigningErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
+    TransactionSigningErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(TransactionSigningErrorCode || (TransactionSigningErrorCode = {}));
+
 // Adapter function to convert backend signature response to legacy format
 const adaptSignatureResponse = (newResponse) => {
     if (!newResponse.signature) {
@@ -889,25 +913,6 @@ class SigningService {
     }
 }
 
-/**
- * Error codes for transaction signing operations
- */
-var TransactionSigningErrorCode;
-(function (TransactionSigningErrorCode) {
-    TransactionSigningErrorCode["INVALID_TOKENS"] = "INVALID_TOKENS";
-    TransactionSigningErrorCode["TRANSACTION_NOT_FOUND"] = "TRANSACTION_NOT_FOUND";
-    TransactionSigningErrorCode["TRANSACTION_NOT_PENDING"] = "TRANSACTION_NOT_PENDING";
-    TransactionSigningErrorCode["WALLET_NOT_AVAILABLE"] = "WALLET_NOT_AVAILABLE";
-    TransactionSigningErrorCode["WEBAUTHN_OPERATION_IN_PROGRESS"] = "WEBAUTHN_OPERATION_IN_PROGRESS";
-    TransactionSigningErrorCode["SIGNING_CANCELLED"] = "SIGNING_CANCELLED";
-    TransactionSigningErrorCode["PERS_AUTH_FAILED"] = "PERS_AUTH_FAILED";
-    TransactionSigningErrorCode["AUTH_FAILED"] = "AUTH_FAILED";
-    TransactionSigningErrorCode["TRANSACTION_NOT_READY"] = "TRANSACTION_NOT_READY";
-    TransactionSigningErrorCode["SUBMISSION_FAILED"] = "SUBMISSION_FAILED";
-    TransactionSigningErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
-    TransactionSigningErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(TransactionSigningErrorCode || (TransactionSigningErrorCode = {}));
-
 /**
  * Handles all error-related operations for transaction signing
  */
@@ -1107,11 +1112,6 @@ class WebAuthnCoordinator {
     }
 }
 
-/**
- * Transaction statuses that allow signing
- */
-const SIGNABLE_STATUSES = [TransactionStatus.PENDING_SIGNATURE, TransactionStatus.CREATED];
-
 /**
  * Service for orchestrating transaction signing operations
  * Handles the complete flow from transaction preparation to submission
@@ -1568,11 +1568,13 @@ class AuthenticationService {
                     throw new Error('Registration completed but no response received');
                 }
             }
-            return {
-                identifier,
+            const user = {
+                identifier: identifier,
                 signerAuthToken: signerToken,
-                persAccessToken
+                persAccessToken: persAccessToken,
+                expiresAt: Date.now() + 300000 // 5 minutes
             };
+            return user;
         }
         catch (error) {
             console.error(`[PersSignerSDK] Combined authentication failed for ${identifier}:`, error);
@@ -1782,25 +1784,17 @@ class PersSignerSDK {
             throw new Error('Invalid or expired JWT token');
         }
         const identifier = payload.identifierEmail || payload.email || payload.userId;
-        const tenantId = payload.tenantId || '';
         if (!identifier) {
             throw new Error('JWT token missing user identifier (identifierEmail, email, or userId)');
         }
         // Check cache first
         const cachedUser = UserCache.get(identifier);
-        if (cachedUser && cachedUser.tenantId === tenantId && Date.now() < cachedUser.expiresAt) {
+        if (cachedUser && Date.now() < cachedUser.expiresAt) {
             return cachedUser;
         }
         try {
             // Authenticate and cache
-            const authResult = await this.authenticationService.combinedAuthentication(identifier, jwtToken);
-            const user = {
-                identifier: authResult.identifier,
-                signerAuthToken: authResult.signerAuthToken,
-                persAccessToken: authResult.persAccessToken,
-                tenantId,
-                expiresAt: Date.now() + 300000 // 5 minutes
-            };
+            const user = await this.authenticationService.combinedAuthentication(identifier, jwtToken);
             UserCache.set(identifier, user);
             return user;
         }
@@ -1840,6 +1834,9 @@ class PersSignerSDK {
         if (!payload?.transactionId) {
             throw new Error('JWT token missing transactionId in payload');
         }
+        if (!payload.tenantId) {
+            throw new Error('JWT token missing tenantId in payload');
+        }
         const authTokens = {
             signerAuthToken: user.signerAuthToken,
             persAccessToken: user.persAccessToken
@@ -1848,7 +1845,7 @@ class PersSignerSDK {
             const persSigningData = await this.transactionSigningService.getPersSigningData({
                 transactionId: payload.transactionId,
                 authTokens,
-                tenantId: user.tenantId
+                tenantId: payload.tenantId
             });
             const result = await this.signTransaction(persSigningData, jwtToken);
             if (!result.success) {
@@ -1890,6 +1887,9 @@ class PersSignerSDK {
         if (!payload?.transactionId) {
             throw new Error('JWT token missing transactionId in payload');
         }
+        if (!payload.tenantId) {
+            throw new Error('JWT token missing tenantId in payload');
+        }
         const authTokens = {
             signerAuthToken: user.signerAuthToken,
             persAccessToken: user.persAccessToken
@@ -1897,7 +1897,7 @@ class PersSignerSDK {
         try {
             const result = await this.transactionSigningService.signTransaction({
                 transactionId: payload.transactionId,
-                tenantId: user.tenantId,
+                tenantId: payload.tenantId,
                 authTokens,
                 ethersProviderUrl: this.config.ethersProviderUrl || ''
             }, signingData);