@swivy/web 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @swivy/web
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Swivy web SDK. Testnet preview; production onboarding is gated on the Swop canary.
+
+Public npm distribution is being prepared. Before first publication, use all SDK tarballs
+from one operator-supplied release and verify its SHA256SUMS. After publication:
+
+```sh
+npm install @swivy/web@next
+```
+
+Use an environment app ID and publishable key for browser/mobile apps. Keep environment
+secret keys on the backend and deployment bootstrap credentials with the deployment operator.
+Choose email or SMS in your environment policy; SMS recovery alone does not enable SMS login.
+Never log login codes, runtime sessions or signing material.
+
+Browser apps currently need a same-origin reverse proxy for `/v1/runtime/*`; the API
+does not advertise cross-origin browser access. Backend and native clients can use the API directly.
+
+The client exposes `requestSmsCode(phoneNumber)` and `verifySmsCode(challengeId, code)`. Supply phone numbers in E.164 format.

package/dist/packages/web/src/index.d.ts

@@ -0,0 +1,515 @@
+import { type AuthenticationResponseJSON, type PublicKeyCredentialCreationOptionsJSON, type PublicKeyCredentialRequestOptionsJSON, type RegistrationResponseJSON } from "@simplewebauthn/browser";
+import type { Chain, CustodyMode, ExecutionResult, LinkedWalletDescriptor, ManagedAccountDescriptor, OfflineTransactionSigningEnvelope, OfflineTransactionSigningResponseEnvelope, SessionGrantDescriptor, SessionGrantScope, TransactionIntent, TypedDataDescriptor, WalletPurpose } from "@swivy/core";
+import { type SwivyLocalWalletShareRecord, type SwivyLocalWalletStorageLike } from "./local-wallet.js";
+export interface SwivyBrowserClientConfig {
+    baseUrl: string;
+    appId?: string;
+    publishableKey?: string;
+    environmentId?: string;
+    /**
+     * Legacy alias for publishableKey while existing apps migrate.
+     */
+    apiKey?: string;
+    sessionToken?: string;
+    sessionPersistence?: SwivySessionPersistenceMode | SwivySessionPersistenceAdapter;
+    sessionStorageKey?: string;
+    embeddedWalletStorage?: SwivyLocalWalletStorageLike;
+    embeddedWalletStorageKeyPrefix?: string;
+    offlineSigningPairingSecret?: string;
+    offlineSigningPairingKeyId?: string;
+}
+export type SwivyChallengePurpose = "login" | "account_export" | "intent_approval" | "recovery" | "session_delegation" | "wallet_reconstruction";
+export type SwivySessionPersistenceMode = "memory" | "localStorage" | "sessionStorage";
+export interface SwivySessionPersistenceAdapter {
+    load(): string | undefined;
+    save(token: string): void;
+    clear(): void;
+}
+export interface SwivyListAccountsPayload {
+    managedAccounts: ManagedAccountDescriptor[];
+    linkedWallets: LinkedWalletDescriptor[];
+}
+export interface SwivyWalletToolDescriptor {
+    id: string;
+    name?: string;
+    description?: string;
+    status?: "enabled" | "disabled" | string;
+    policy?: unknown;
+    [key: string]: unknown;
+}
+export interface SwivyWalletToolsPayload {
+    tools: SwivyWalletToolDescriptor[];
+}
+export interface SwivyLifiQuotePayload {
+    accountId: string;
+    fromChain: number;
+    toChain: number;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    requestedValueUsd?: number | null;
+    toAddress?: string;
+    slippage?: number;
+    allowBridges?: string[];
+    denyBridges?: string[];
+    allowExchanges?: string[];
+    denyExchanges?: string[];
+}
+export interface SwivyJupiterQuotePayload {
+    accountId: string;
+    inputMint: string;
+    outputMint: string;
+    amount: string;
+    requestedValueUsd?: number | null;
+    slippageBps?: number;
+    swapMode?: "ExactIn" | "ExactOut";
+    buildTransaction?: boolean;
+    dynamicComputeUnitLimit?: boolean;
+    dynamicSlippage?: boolean;
+    prioritizationFeeLamports?: number | Record<string, unknown>;
+}
+export type SwivySwapQuotePayload = (SwivyLifiQuotePayload & {
+    provider: "lifi";
+    buildTransaction?: boolean;
+}) | (SwivyJupiterQuotePayload & {
+    provider: "jupiter";
+});
+export type SwivyAuthenticateOptions = {
+    method?: "email";
+    email: string;
+    code: string;
+    externalUserId?: string;
+} | {
+    method: "oidc";
+    token: string;
+} | {
+    method: "wallet";
+    chain: Chain;
+    address: string;
+    challengeId: string;
+    signature: string;
+};
+export interface SwivyWalletLoginRequestOptions {
+    chain: Chain;
+    address: string;
+    connectorType?: string;
+    externalUserId?: string;
+}
+export interface SwivyWalletLoginChallenge {
+    challengeId: string;
+    chain: Chain;
+    address: string;
+    message: string;
+    nonce: string;
+    expiresAt: string;
+}
+export interface SwivyWalletLoginVerifyOptions {
+    chain: Chain;
+    address: string;
+    challengeId: string;
+    signature: string;
+}
+export interface SwivyWaitForIntentOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+}
+export interface SwivyManagedAccountResolution {
+    account: ManagedAccountDescriptor;
+    existing: boolean;
+    attestation?: unknown;
+}
+export interface SwivyManagedAccountCreateOptions {
+    label?: string;
+    purpose?: WalletPurpose;
+    custodyMode?: CustodyMode;
+    splitCustody?: {
+        deviceShare: {
+            commitment: string;
+            encryptedPayload?: string;
+            metadata?: Record<string, unknown>;
+        };
+        recoveryShare?: {
+            commitment: string;
+            encryptedPayload?: string;
+            metadata?: Record<string, unknown>;
+        };
+    };
+}
+export interface SwivyBrowserSplitWalletCreateResult extends SwivyManagedAccountResolution {
+    recoveryPackage?: string;
+    deviceShare: SwivyLocalWalletShareRecord;
+    recoveryShare?: SwivyLocalWalletShareRecord;
+}
+export interface SwivyLocalExportOptions {
+    recoveryPackage?: string;
+    challengeId?: string;
+}
+export interface SwivyOfflineTransactionSigningOptions extends SwivyLocalExportOptions {
+    pairingSecret?: string;
+    requireSignature?: boolean;
+    localApproval?: {
+        type: "passkey";
+        verifiedAt: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface SwivyLocalSigningResult {
+    accountId: string;
+    chain: Chain;
+    signature?: string;
+    signedPayload?: string;
+    signerAddress: string;
+    signerPublicKey: string;
+}
+export interface SwivyExportedAccountPayload {
+    accountId: string;
+    chain: Chain;
+    privateKey: string;
+    attestation: unknown;
+}
+export interface SwivyRawSignPayload {
+    result: ExecutionResult;
+}
+export interface SwivySigningPayload {
+    accountId: string;
+    chain: Chain;
+    challengeId?: string;
+    payload: Record<string, unknown>;
+}
+export interface SwivyTypedDataSigningPayload {
+    accountId: string;
+    challengeId?: string;
+    typedData: TypedDataDescriptor;
+}
+export interface SwivyPasskeyRegistrationStartPayload {
+    authMethod: {
+        id: string;
+        type: "passkey";
+        label: string;
+        active: boolean;
+        recoveryCapable: boolean;
+    };
+    challengeId: string;
+    methodType: "passkey";
+    options: PublicKeyCredentialCreationOptionsJSON;
+    expiresAt: string;
+}
+export interface SwivyPasskeyChallengePayload {
+    challengeId: string;
+    purpose: SwivyChallengePurpose;
+    expiresAt: string;
+    methodType: "passkey";
+    options: PublicKeyCredentialRequestOptionsJSON;
+}
+export interface SwivyPasskeyApprovalOptions {
+    useBrowserAutofill?: boolean;
+    verifyBrowserAutofillInput?: boolean;
+}
+export interface SwivyPasskeyApprovalResult {
+    challenge: SwivyPasskeyChallengePayload;
+    verification: unknown;
+    authenticationResponse: AuthenticationResponseJSON;
+}
+export type SwivyWebAuthnOperation = "passkey_registration" | SwivyChallengePurpose;
+export type SwivyWebAuthnErrorCode = "webauthn_not_supported" | "webauthn_wrong_origin" | "webauthn_stale_challenge" | "webauthn_missing_credential" | "webauthn_canceled" | "webauthn_credential_already_registered" | "webauthn_not_allowed" | "webauthn_failed";
+export declare class SwivyWebAuthnError extends Error {
+    readonly name = "SwivyWebAuthnError";
+    readonly code: SwivyWebAuthnErrorCode;
+    readonly operation: SwivyWebAuthnOperation;
+    readonly retryable: boolean;
+    readonly recoveryHint: string;
+    readonly browserErrorName: string | null;
+    readonly rawMessage: string | null;
+    readonly cause: unknown;
+    constructor(params: {
+        code: SwivyWebAuthnErrorCode;
+        operation: SwivyWebAuthnOperation;
+        userMessage: string;
+        retryable: boolean;
+        recoveryHint: string;
+        browserErrorName?: string | null;
+        rawMessage?: string | null;
+        cause: unknown;
+    });
+}
+export declare function isSwivyWebAuthnError(error: unknown): error is SwivyWebAuthnError;
+export interface SwivyLocalPasskeyOperationOptions extends SwivyPasskeyApprovalOptions {
+    recoveryPackage?: string;
+}
+export interface SwivyApprovedLocalOperationResult<T> {
+    approval: SwivyPasskeyApprovalResult;
+    result: T;
+}
+export interface SwivyRuntimeAuthMethod {
+    id: string;
+    type: string;
+    label: string;
+    active: boolean;
+    recoveryCapable?: boolean;
+}
+export interface SwivyRuntimeSession {
+    sessionToken?: string;
+    managedAccounts?: ManagedAccountDescriptor[];
+    linkedWallets?: LinkedWalletDescriptor[];
+    walletTools?: SwivyWalletToolDescriptor[];
+    authMethods?: SwivyRuntimeAuthMethod[];
+    environmentPolicy?: {
+        allowedChains?: Chain[];
+        walletPolicy?: {
+            allowManagedAccounts?: boolean;
+            allowSplitCustody?: boolean;
+            autoCreateManagedAccounts?: boolean;
+            defaultCustodyMode?: CustodyMode;
+            managedAccountChains?: Chain[];
+        };
+        offlineSigningPolicy?: {
+            enabled?: boolean;
+            bluetoothMeshEnabled?: boolean;
+            qrFallbackEnabled?: boolean;
+            nfcFallbackEnabled?: boolean;
+            fileFallbackEnabled?: boolean;
+            requireSplitCustody?: boolean;
+            requirePasskeyApproval?: boolean;
+            allowRecoveryPackageSigning?: boolean;
+            maxEnvelopeTtlSeconds?: number | null;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface SwivyPasskeyEnsureResult {
+    authMethod: SwivyRuntimeAuthMethod;
+    existing: boolean;
+    enrollment?: Awaited<ReturnType<SwivyBrowserClient["enrollPasskey"]>>;
+}
+export interface SwivyPreparedLocalWalletResult {
+    account: ManagedAccountDescriptor;
+    passkey: SwivyPasskeyEnsureResult;
+    approval: SwivyPasskeyApprovalResult;
+}
+export declare class SwivyBrowserClient {
+    private readonly config;
+    sessionToken?: string;
+    private readonly sessionTokenListeners;
+    private readonly sessionPersistence?;
+    private readonly embeddedWalletStorage?;
+    private readonly embeddedWalletStorageKeyPrefix;
+    constructor(config: SwivyBrowserClientConfig);
+    getSessionToken(): string | undefined;
+    setSessionToken(token: string | undefined): void;
+    clearSessionToken(): void;
+    onSessionTokenChange(listener: (token: string | undefined) => void): () => void;
+    requestEmailCode(email: string, externalUserId?: string): Promise<any>;
+    verifyEmailCode(email: string, code: string, externalUserId?: string): Promise<any>;
+    verifyEmailCodeAndBootstrapWallets(email: string, code: string, externalUserId?: string): Promise<SwivyRuntimeSession>;
+    /** Create a new account with a passkey only (Privy signupWithPasskey). */
+    signupWithPasskey(options?: {
+        displayName?: string;
+    }): Promise<SwivyRuntimeSession>;
+    /** Log in with any passkey registered for this app (Privy loginWithPasskey). */
+    loginWithPasskey(options?: {
+        useBrowserAutofill?: boolean;
+    }): Promise<SwivyRuntimeSession>;
+    /** Send a login code by SMS (Privy loginWithSMS, step 1). Phone in E.164, e.g. +14155550123. */
+    requestSmsCode(phoneNumber: string): Promise<{
+        challengeId: string;
+        phoneNumber: string;
+        expiresAt: string;
+    }>;
+    verifySmsCode(challengeId: string, code: string): Promise<SwivyRuntimeSession>;
+    exchangeOidcToken(token: string): Promise<any>;
+    exchangeOidcTokenAndBootstrapWallets(token: string): Promise<SwivyRuntimeSession>;
+    requestWalletLogin(options: SwivyWalletLoginRequestOptions): Promise<SwivyWalletLoginChallenge>;
+    verifyWalletLogin(options: SwivyWalletLoginVerifyOptions): Promise<any>;
+    verifyWalletLoginAndBootstrapWallets(options: SwivyWalletLoginVerifyOptions): Promise<SwivyRuntimeSession>;
+    authenticate(options: SwivyAuthenticateOptions): Promise<SwivyRuntimeSession>;
+    hydrateRuntimeSession(): Promise<SwivyRuntimeSession>;
+    startTotp(label?: string): Promise<any>;
+    verifyTotp(authMethodId: string, code: string): Promise<any>;
+    startSmsEnrollment(phoneNumber: string, label?: string): Promise<any>;
+    verifySmsEnrollment(authMethodId: string, challengeId: string, code: string): Promise<any>;
+    getMe(): Promise<any>;
+    createManagedAccount(chain: Chain, options?: string | SwivyManagedAccountCreateOptions): Promise<any>;
+    listAccounts(): Promise<SwivyListAccountsPayload>;
+    listWalletTools(): Promise<SwivyWalletToolsPayload>;
+    createLifiQuote(body: SwivyLifiQuotePayload): Promise<any>;
+    createJupiterQuote(body: SwivyJupiterQuotePayload): Promise<any>;
+    createSwapQuote(body: SwivySwapQuotePayload): Promise<any>;
+    listEmbeddedWallets(): Promise<ManagedAccountDescriptor[]>;
+    getManagedAccount(chain: Chain, options?: {
+        purpose?: WalletPurpose;
+    }): Promise<ManagedAccountDescriptor | null>;
+    getEmbeddedWallet(chain: Chain): Promise<ManagedAccountDescriptor | null>;
+    ensureManagedAccount(chain: Chain, options?: string | SwivyManagedAccountCreateOptions): Promise<SwivyManagedAccountResolution>;
+    ensureEmbeddedWallet(chain: Chain, options?: string | SwivyManagedAccountCreateOptions): Promise<SwivyManagedAccountResolution>;
+    bootstrapEmbeddedWallets(payload?: SwivyRuntimeSession): Promise<SwivyRuntimeSession>;
+    createChallenge(authMethodId: string, purpose: SwivyChallengePurpose): Promise<any>;
+    verifyChallenge(challengeId: string, payload: Record<string, unknown>): Promise<any>;
+    isWebAuthnSupported(): Promise<boolean>;
+    isPlatformAuthenticatorAvailable(): Promise<boolean>;
+    isWebAuthnAutofillSupported(): Promise<boolean>;
+    startPasskeyRegistration(label?: string): Promise<SwivyPasskeyRegistrationStartPayload>;
+    finishPasskeyRegistration(authMethodId: string, challengeId: string, registrationResponse: RegistrationResponseJSON): Promise<any>;
+    enrollPasskey(label?: string, options?: {
+        useAutoRegister?: boolean;
+    }): Promise<any>;
+    ensurePasskey(label?: string, options?: {
+        useAutoRegister?: boolean;
+    }): Promise<SwivyPasskeyEnsureResult>;
+    completePasskeyChallenge(challengeId: string, optionsJSON: PublicKeyCredentialRequestOptionsJSON, operation: SwivyWebAuthnOperation, options?: {
+        useBrowserAutofill?: boolean;
+        verifyBrowserAutofillInput?: boolean;
+    }): Promise<{
+        verification: any;
+        authenticationResponse: AuthenticationResponseJSON;
+    }>;
+    approveWithPasskey(authMethodId: string, purpose: SwivyChallengePurpose, options?: SwivyPasskeyApprovalOptions): Promise<SwivyPasskeyApprovalResult>;
+    approveWalletReconstructionWithPasskey(authMethodId: string, options?: SwivyPasskeyApprovalOptions): Promise<SwivyPasskeyApprovalResult>;
+    prepareLocalWalletWithPasskey(accountId: string, options?: SwivyLocalPasskeyOperationOptions & {
+        authMethodId?: string;
+        passkeyLabel?: string;
+        useAutoRegister?: boolean;
+    }): Promise<SwivyPreparedLocalWalletResult>;
+    createSigningIntent(body: Record<string, unknown>): Promise<any>;
+    createTransactionIntent(body: Record<string, unknown>): Promise<any>;
+    getIntent(intentId: string): Promise<any>;
+    waitForIntent(intentId: string, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    createSigningIntentAndWait(body: Record<string, unknown>, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    signMessageAndWait(body: SwivySigningPayload & {
+        payload: {
+            message?: string;
+            messageHex?: string;
+            messageBase64?: string;
+        };
+    }, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    signTypedDataAndWait(body: SwivyTypedDataSigningPayload, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    signTransactionAndWait(body: SwivySigningPayload & {
+        payload: {
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+        };
+    }, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    createTransactionIntentAndWait(body: Record<string, unknown>, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    executeTransactionAndWait(body: Record<string, unknown>, options?: SwivyWaitForIntentOptions): Promise<TransactionIntent>;
+    exportManagedAccount(accountId: string, challengeId: string): Promise<SwivyExportedAccountPayload>;
+    rawSign(accountId: string, challengeId: string, payload: Record<string, unknown>): Promise<SwivyRawSignPayload>;
+    getAccountCustody(accountId: string): Promise<any>;
+    enableSplitCustody(accountId: string, splitCustody: NonNullable<SwivyManagedAccountCreateOptions["splitCustody"]>): Promise<any>;
+    createSessionGrant(body: {
+        accountId: string;
+        publicKey: string;
+        label?: string;
+        challengeId?: string;
+        expiresInSeconds?: number;
+        scope?: Partial<SessionGrantScope>;
+    }): Promise<{
+        sessionGrant: SessionGrantDescriptor;
+    }>;
+    listSessionGrants(): Promise<{
+        sessionGrants: SessionGrantDescriptor[];
+    }>;
+    revokeSessionGrant(grantId: string): Promise<{
+        sessionGrant: SessionGrantDescriptor;
+    }>;
+    createBrowserSplitWallet(chain: Chain, options?: {
+        label?: string;
+    }): Promise<SwivyBrowserSplitWalletCreateResult>;
+    ensureBrowserSplitWallet(chain: Chain, options?: {
+        label?: string;
+    }): Promise<SwivyBrowserSplitWalletCreateResult>;
+    getServerShare(accountId: string, challengeId: string): Promise<any>;
+    hasLocalEmbeddedWallet(accountId: string): boolean;
+    clearLocalEmbeddedWallet(accountId: string): void;
+    getLocalEmbeddedWalletShare(accountId: string): SwivyLocalWalletShareRecord | null;
+    exportEmbeddedWalletLocally(accountId: string, options?: SwivyLocalExportOptions): Promise<{
+        accountId: string;
+        chain: Chain;
+        privateKey: string;
+        publicKey: string;
+        address: string;
+        local: boolean;
+    }>;
+    exportEmbeddedWalletLocallyWithPasskey(accountId: string, authMethodId: string, options?: SwivyLocalPasskeyOperationOptions): Promise<SwivyApprovedLocalOperationResult<Awaited<ReturnType<SwivyBrowserClient["exportEmbeddedWalletLocally"]>>>>;
+    signMessageLocally(body: {
+        accountId: string;
+        chain: Chain;
+        payload: {
+            message?: string;
+            messageHex?: string;
+            messageBase64?: string;
+        };
+    }, options?: SwivyLocalExportOptions): Promise<SwivyLocalSigningResult>;
+    signMessageLocallyWithPasskey(body: {
+        accountId: string;
+        chain: Chain;
+        payload: {
+            message?: string;
+            messageHex?: string;
+            messageBase64?: string;
+        };
+    }, authMethodId: string, options?: SwivyLocalPasskeyOperationOptions): Promise<SwivyApprovedLocalOperationResult<SwivyLocalSigningResult>>;
+    signTypedDataLocally(body: {
+        accountId: string;
+        typedData: TypedDataDescriptor;
+    }, options?: SwivyLocalExportOptions): Promise<SwivyLocalSigningResult>;
+    signTypedDataLocallyWithPasskey(body: {
+        accountId: string;
+        typedData: TypedDataDescriptor;
+    }, authMethodId: string, options?: SwivyLocalPasskeyOperationOptions): Promise<SwivyApprovedLocalOperationResult<SwivyLocalSigningResult>>;
+    signTransactionLocally(body: {
+        accountId: string;
+        chain: Chain;
+        payload: {
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+        };
+    }, options?: SwivyLocalExportOptions): Promise<SwivyLocalSigningResult>;
+    signTransactionLocallyWithPasskey(body: {
+        accountId: string;
+        chain: Chain;
+        payload: {
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+        };
+    }, authMethodId: string, options?: SwivyLocalPasskeyOperationOptions): Promise<SwivyApprovedLocalOperationResult<SwivyLocalSigningResult>>;
+    createOfflineTransactionSigningEnvelope(body: {
+        accountId: string;
+        chain: Chain;
+        payload: {
+            network?: string | null;
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+            requestedValueUsd?: number | null;
+        };
+        expiresAt?: Date | string | null;
+        requester?: OfflineTransactionSigningEnvelope["requester"];
+        metadata?: Record<string, unknown>;
+    }): Promise<OfflineTransactionSigningEnvelope>;
+    signOfflineTransactionSigningEnvelope(envelope: OfflineTransactionSigningEnvelope | string, options?: SwivyOfflineTransactionSigningOptions): Promise<OfflineTransactionSigningResponseEnvelope>;
+    encodeOfflineSigningEnvelope(envelope: OfflineTransactionSigningEnvelope | OfflineTransactionSigningResponseEnvelope): string;
+    decodeOfflineSigningEnvelope(envelope: string): OfflineTransactionSigningEnvelope | OfflineTransactionSigningResponseEnvelope;
+    importOfflineTransactionSigningResponse(envelope: OfflineTransactionSigningResponseEnvelope | string, options?: {
+        network?: string | null;
+        broadcast?: boolean;
+        policySnapshotHash?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        imported: boolean;
+        broadcast: unknown | null;
+    }>;
+    private request;
+    private assertWebAuthnSupport;
+    private resolveSessionPersistence;
+    private resolveEmbeddedWalletStorage;
+    private requireEmbeddedWalletStorage;
+    private getMissingSplitCustodyChains;
+    private attachWalletTools;
+    private requireManagedAccountById;
+    private loadReconstructionShares;
+    private reportLocalSigningActivity;
+    private offlineSigningReplayStorageKey;
+    private hasSeenOfflineSigningRequest;
+    private markOfflineSigningRequestSeen;
+    private reportOfflineSigningActivity;
+    private delay;
+}