Class GunInstance

Constructors

constructor

Properties

_rxjs? crypto eventEmitter gun node onAuthCallbacks rateLimitStorage sea user Errors

Methods

addPeer authenticateNewUser buildFrozenPath buildLoginResult changeUsername checkRateLimit checkUserExistence checkUsernameExists clearGunStorage clearSession createFrozenSpace createLookupStrategies createNewUser createNewUserWithPair decryptSessionData derive deriveAll deriveBitcoin deriveEthereum deriveP256 emit emitDataEvent emitPeerEvent encryptSessionData forgotPassword generateFrozenDataHash get getAllConfiguredPeers getAppScope getCurrentPeers getCurrentUser getData getFrozenSpace getGun getPasswordHint getPeerInfo getUser getUserData getUsername getUserPub initialize isAuthenticated isLoggedIn leave loadSession login logout lookupAlternateKey lookupComprehensiveScan lookupDirectMapping lookupInFrozenSpace navigateToPath normalizeUsername notifyAuthListeners off on onAuth once performAuthentication prepareFrozenData processLookupResult put putUserData recall reconnectToPeer remove removePeer resetPeers resetRateLimit resetRateLimitForUser restoreSession runPostAuthOnAuthResult rx sanitizeUsername saveCredentials saveSession set setPasswordHint setPasswordHintWithSecurity setUserData setUsername signUp storeFrozenData subscribeToAuthEvents testConnectivity updateUserAlias validatePasswordStrength validateSignupCredentials verifyFrozenSpace

Constructors

constructor

  • new GunInstance(gun: IGunInstance<any>, appScope?: string): GunInstance

    Parameters

    • gun: IGunInstance<any>
    • appScope: string = "shogun"

    Returns GunInstance

Properties

Private Optional_rxjs

_rxjs?: GunRxJS

crypto

crypto: crypto

Private ReadonlyeventEmitter

eventEmitter: EventEmitter

gun

gun: IGunInstance<any>

node

node: IGunChain<any, IGunInstance<any>, IGunInstance<any>, string>

Private ReadonlyonAuthCallbacks

onAuthCallbacks: AuthCallback[] = []

Private ReadonlyrateLimitStorage

rateLimitStorage: Map<string, RateLimitEntry> = ...

sea

sea: SEA

user

user: null | IGunUserInstance<any, any, any, any> = null

StaticErrors

Errors: GunErrors = GunErrors

Methods

addPeer

  • addPeer(peer: string): void

    Adds a new peer to the network

    Parameters

    • peer: string

      URL of the peer to add

    Returns void

PrivateauthenticateNewUser

  • authenticateNewUser(
        username: string,
        password: string,
        pair?: null | ISEAPair,
    ): Promise<{ error?: string; success: boolean; userPub?: string }>

    Authenticates user after creation

    Parameters

    • username: string
    • password: string
    • Optionalpair: null | ISEAPair

    Returns Promise<{ error?: string; success: boolean; userPub?: string }>

PrivatebuildFrozenPath

  • buildFrozenPath(
        hash: string,
        options?: { namespace?: string; path?: string },
    ): string

    Builds the full path for frozen data

    Parameters

    • hash: string
    • Optionaloptions: { namespace?: string; path?: string }

    Returns string

PrivatebuildLoginResult

  • buildLoginResult(username: string, userPub: string): AuthResult

    Builds login result object

    Parameters

    • username: string
    • userPub: string

    Returns AuthResult

changeUsername

  • changeUsername(
        newUsername: string,
    ): Promise<
        {
            error?: string;
            newUsername?: string;
            oldUsername?: string;
            success: boolean;
        },
    >

    Changes the username for the currently authenticated user

    Parameters

    • newUsername: string

      New username to set

    Returns Promise<
        {
            error?: string;
            newUsername?: string;
            oldUsername?: string;
            success: boolean;
        },
    >

    Promise resolving to the operation result

checkRateLimit

  • checkRateLimit(
        username: string,
        operation: "login" | "signup",
    ): { allowed: boolean; error?: string }

    Checks rate limiting for login attempts

    Parameters

    • username: string
    • operation: "login" | "signup"

    Returns { allowed: boolean; error?: string }

PrivatecheckUserExistence

  • checkUserExistence(
        username: string,
        password: string,
        pair?: null | ISEAPair,
    ): Promise<UserExistenceResult>

    Checks if user exists by attempting authentication

    Parameters

    • username: string
    • password: string
    • Optionalpair: null | ISEAPair

    Returns Promise<UserExistenceResult>

checkUsernameExists

  • checkUsernameExists(username: string): Promise<any>

    Parameters

    • username: string

    Returns Promise<any>

clearGunStorage

  • clearGunStorage(): void

    Debug method: Clears all Gun-related data from local and session storage This is useful for debugging and testing purposes

    Returns void

    Warning

    This will completely reset the user's local Gun data

clearSession

  • clearSession(): void

    Clear session

    Returns void

createFrozenSpace

  • createFrozenSpace(
        data: any,
        options?: {
            description?: string;
            metadata?: Record<string, any>;
            namespace?: string;
            path?: string;
        },
    ): Promise<{ data: any; fullPath: string; hash: string }>

    Creates a frozen space entry for immutable data

    Parameters

    • data: any

      Data to freeze

    • Optionaloptions: {
          description?: string;
          metadata?: Record<string, any>;
          namespace?: string;
          path?: string;
      }

      Optional configuration

    Returns Promise<{ data: any; fullPath: string; hash: string }>

    Promise resolving to the frozen data hash

PrivatecreateLookupStrategies

  • createLookupStrategies(
        normalizedUsername: string,
        frozenKey: string,
        alternateKey: string,
    ): () => Promise<null | UsernameLookupResult>[]

    Creates lookup strategies array

    Parameters

    • normalizedUsername: string
    • frozenKey: string
    • alternateKey: string

    Returns () => Promise<null | UsernameLookupResult>[]

PrivatecreateNewUser

  • createNewUser(
        username: string,
        password: string,
    ): Promise<{ error?: string; success: boolean; userPub?: string }>

    Creates a new user in Gun

    Parameters

    • username: string
    • password: string

    Returns Promise<{ error?: string; success: boolean; userPub?: string }>

PrivatecreateNewUserWithPair

  • createNewUserWithPair(
        username: string,
        pair: ISEAPair,
    ): Promise<{ error?: string; success: boolean; userPub?: string }>

    Creates a new user in Gun with pair-based authentication (for Web3/plugins)

    Parameters

    • username: string
    • pair: ISEAPair

    Returns Promise<{ error?: string; success: boolean; userPub?: string }>

PrivatedecryptSessionData

  • decryptSessionData(encryptedData: string): Promise<any>

    Decrypts session data from storage

    Parameters

    • encryptedData: string

    Returns Promise<any>

derive

  • derive(
        password: string | number,
        extra?: string | string[],
        options?: DeriveOptions,
    ): Promise<
        {
            p256?: { epriv: string; epub: string; priv: string; pub: string };
            secp256k1Bitcoin?: { address: string; priv: string; pub: string };
            secp256k1Ethereum?: { address: string; priv: string; pub: string };
        },
    >

    Derive cryptographic keys from password and optional extras Supports multiple key derivation algorithms: P-256, secp256k1 (Bitcoin), secp256k1 (Ethereum)

    Parameters

    • password: string | number

      Password or seed for key derivation

    • Optionalextra: string | string[]

      Additional entropy (string or array of strings)

    • Optionaloptions: DeriveOptions

      Derivation options to specify which key types to generate

    Returns Promise<
        {
            p256?: { epriv: string; epub: string; priv: string; pub: string };
            secp256k1Bitcoin?: { address: string; priv: string; pub: string };
            secp256k1Ethereum?: { address: string; priv: string; pub: string };
        },
    >

    Promise resolving to derived keys object

deriveAll

  • deriveAll(
        password: string | number,
        extra?: string | string[],
    ): Promise<
        {
            p256: { epriv: string; epub: string; priv: string; pub: string };
            secp256k1Bitcoin: { address: string; priv: string; pub: string };
            secp256k1Ethereum: { address: string; priv: string; pub: string };
        },
    >

    Derive all supported key types

    Parameters

    • password: string | number

      Password for key derivation

    • Optionalextra: string | string[]

      Additional entropy

    Returns Promise<
        {
            p256: { epriv: string; epub: string; priv: string; pub: string };
            secp256k1Bitcoin: { address: string; priv: string; pub: string };
            secp256k1Ethereum: { address: string; priv: string; pub: string };
        },
    >

    Promise resolving to all key types

deriveBitcoin

  • deriveBitcoin(
        password: string | number,
        extra?: string | string[],
    ): Promise<{ address: string; priv: string; pub: string }>

    Derive Bitcoin secp256k1 keys with P2PKH address

    Parameters

    • password: string | number

      Password for key derivation

    • Optionalextra: string | string[]

      Additional entropy

    Returns Promise<{ address: string; priv: string; pub: string }>

    Promise resolving to Bitcoin keys and address

deriveEthereum

  • deriveEthereum(
        password: string | number,
        extra?: string | string[],
    ): Promise<{ address: string; priv: string; pub: string }>

    Derive Ethereum secp256k1 keys with Keccak256 address

    Parameters

    • password: string | number

      Password for key derivation

    • Optionalextra: string | string[]

      Additional entropy

    Returns Promise<{ address: string; priv: string; pub: string }>

    Promise resolving to Ethereum keys and address

deriveP256

  • deriveP256(
        password: string | number,
        extra?: string | string[],
    ): Promise<{ epriv: string; epub: string; priv: string; pub: string }>

    Derive P-256 keys (default Gun.SEA behavior)

    Parameters

    • password: string | number

      Password for key derivation

    • Optionalextra: string | string[]

      Additional entropy

    Returns Promise<{ epriv: string; epub: string; priv: string; pub: string }>

    Promise resolving to P-256 keys

emit

  • emit(event: string | symbol, data?: any): boolean

    Emits an event

    Parameters

    • event: string | symbol

      Event name

    • Optionaldata: any

      Event data

    Returns boolean

PrivateemitDataEvent

  • emitDataEvent(
        eventType: "gun:put" | "gun:get" | "gun:set" | "gun:remove",
        path: string,
        data?: any,
        success?: boolean,
        error?: string,
    ): void
    Private

    Emits a Gun data event

    Parameters

    • eventType: "gun:put" | "gun:get" | "gun:set" | "gun:remove"
    • path: string
    • Optionaldata: any
    • success: boolean = true
    • Optionalerror: string

    Returns void

PrivateemitPeerEvent

  • emitPeerEvent(
        action: "add" | "remove" | "connect" | "disconnect",
        peer: string,
    ): void
    Private

    Emits a Gun peer event

    Parameters

    • action: "add" | "remove" | "connect" | "disconnect"
    • peer: string

    Returns void

PrivateencryptSessionData

  • encryptSessionData(data: any): Promise<string>

    Encrypts session data before storage

    Parameters

    • data: any

    Returns Promise<string>

forgotPassword

  • forgotPassword(
        username: string,
        securityAnswers: string[],
    ): Promise<{ error?: string; hint?: string; success: boolean }>

    Recovers password hint using security question answers

    Parameters

    • username: string

      Username

    • securityAnswers: string[]

      Array of answers to security questions

    Returns Promise<{ error?: string; hint?: string; success: boolean }>

    Promise resolving with the password hint

PrivategenerateFrozenDataHash

  • generateFrozenDataHash(frozenData: any): Promise<null | string>

    Generates hash for frozen data

    Parameters

    • frozenData: any

    Returns Promise<null | string>

get

  • get(path: string): any

    Gets a node at the specified path

    Parameters

    • path: string

      Path to the node

    Returns any

    Gun node

getAllConfiguredPeers

  • getAllConfiguredPeers(): string[]

    Gets the list of all configured peers (connected and disconnected)

    Returns string[]

    Array of peer URLs

getAppScope

  • getAppScope(): string

    Get app scope

    Returns string

getCurrentPeers

  • getCurrentPeers(): string[]

    Gets the list of currently connected peers

    Returns string[]

    Array of peer URLs

getCurrentUser

  • getCurrentUser(): null | UserInfo

    Gets the current user

    Returns null | UserInfo

    Current user object or null

getData

  • getData(path: string): Promise<any>

    Gets data at the specified path (one-time read)

    Parameters

    • path: string

      Path to get the data from

    Returns Promise<any>

    Promise resolving to the data

getFrozenSpace

  • getFrozenSpace(hash: string, namespace?: string, path?: string): Promise<any>

    Retrieves data from frozen space

    Parameters

    • hash: string

      Hash of the frozen data

    • namespace: string = "default"

      Optional namespace

    • Optionalpath: string

      Optional custom path

    Returns Promise<any>

    Promise resolving to the frozen data

getGun

  • getGun(): IGunInstance<any>

    Gets the Gun instance

    Returns IGunInstance<any>

    Gun instance

getPasswordHint

  • getPasswordHint(): null | string

    Get password hint

    Returns null | string

getPeerInfo

  • getPeerInfo(): { [peer: string]: { connected: boolean; status: string } }

    Gets detailed information about all peers

    Returns { [peer: string]: { connected: boolean; status: string } }

    Object with peer information

getUser

  • getUser(): GunUser

    Gets the current user instance

    Returns GunUser

    User instance

getUserData

  • getUserData(path: string): Promise<any>

    Gets user data from the specified path

    Parameters

    • path: string

      Path to get the data from (supports nested paths like "test/data/marco")

    Returns Promise<any>

    Promise that resolves with the data

getUsername

  • getUsername(): null | string

    Get username for the current user

    Returns null | string

getUserPub

  • getUserPub(): null | string

    Get user public key

    Returns null | string

initialize

  • initialize(appScope?: string): Promise<void>

    Initialize the GunInstance asynchronously This method should be called after construction to perform async operations

    Parameters

    • appScope: string = "shogun"

    Returns Promise<void>

isAuthenticated

  • isAuthenticated(): boolean

    Check if user is authenticated

    Returns boolean

isLoggedIn

  • isLoggedIn(): boolean

    Checks if a user is currently logged in

    Returns boolean

    True if logged in

leave

  • leave(): void

    Leave user session

    Returns void

loadSession

  • loadSession(): any

    Load session from storage

    Returns any

login

  • login(
        username: string,
        password: string,
        pair?: null | ISEAPair,
    ): Promise<AuthResult>

    Parameters

    • username: string
    • password: string
    • Optionalpair: null | ISEAPair

    Returns Promise<AuthResult>

logout

  • logout(): void

    Returns void

PrivatelookupAlternateKey

  • lookupAlternateKey(
        normalizedUsername: string,
        alternateKey: string,
    ): Promise<null | UsernameLookupResult>

    Strategy 3: Alternate key lookup

    Parameters

    • normalizedUsername: string
    • alternateKey: string

    Returns Promise<null | UsernameLookupResult>

PrivatelookupComprehensiveScan

  • lookupComprehensiveScan(
        normalizedUsername: string,
        frozenKey: string,
        alternateKey: string,
    ): Promise<null | UsernameLookupResult>

    Strategy 4: Comprehensive scan fallback

    Parameters

    • normalizedUsername: string
    • frozenKey: string
    • alternateKey: string

    Returns Promise<null | UsernameLookupResult>

PrivatelookupDirectMapping

  • lookupDirectMapping(
        normalizedUsername: string,
        frozenKey: string,
    ): Promise<null | UsernameLookupResult>

    Strategy 2: Direct frozen mapping lookup

    Parameters

    • normalizedUsername: string
    • frozenKey: string

    Returns Promise<null | UsernameLookupResult>

PrivatelookupInFrozenSpace

  • lookupInFrozenSpace(
        normalizedUsername: string,
    ): Promise<null | UsernameLookupResult>

    Strategy 1: Frozen space scan for immutable data

    Parameters

    • normalizedUsername: string

    Returns Promise<null | UsernameLookupResult>

PrivatenavigateToPath

  • navigateToPath(node: any, path: string): any

    Helper method to navigate to a nested path by splitting and chaining .get() calls

    Parameters

    • node: any

      Starting Gun node

    • path: string

      Path string (e.g., "test/data/marco")

    Returns any

    Gun node at the specified path

PrivatenormalizeUsername

  • normalizeUsername(
        username: string,
    ): { alternateKey: string; frozenKey: string; normalizedUsername: string }

    Normalizes username for consistent lookup

    Parameters

    • username: string

    Returns { alternateKey: string; frozenKey: string; normalizedUsername: string }

PrivatenotifyAuthListeners

  • notifyAuthListeners(pub: string): void

    Parameters

    • pub: string

    Returns void

off

  • off(event: string | symbol, listener: EventListener): void

    Removes an event listener

    Parameters

    • event: string | symbol

      Event name

    • listener: EventListener

      Event listener function

    Returns void

on

  • on(event: string | symbol, listener: EventListener): void

    Adds an event listener

    Parameters

    • event: string | symbol

      Event name

    • listener: EventListener

      Event listener function

    Returns void

onAuth

  • onAuth(callback: AuthCallback): () => void

    Registers an authentication callback

    Parameters

    • callback: AuthCallback

      Function to call on auth events

    Returns () => void

    Function to unsubscribe the callback

once

  • once(event: string | symbol, listener: EventListener): void

    Adds a one-time event listener

    Parameters

    • event: string | symbol

      Event name

    • listener: EventListener

      Event listener function

    Returns void

PrivateperformAuthentication

  • performAuthentication(
        username: string,
        password: string,
        pair?: null | ISEAPair,
    ): Promise<{ ack?: any; error?: string; success: boolean }>

    Performs authentication with Gun

    Parameters

    • username: string
    • password: string
    • Optionalpair: null | ISEAPair

    Returns Promise<{ ack?: any; error?: string; success: boolean }>

PrivateprepareFrozenData

  • prepareFrozenData(
        data: any,
        options?: { description?: string; metadata?: Record<string, any> },
    ): any

    Prepares data for freezing with metadata

    Parameters

    • data: any
    • Optionaloptions: { description?: string; metadata?: Record<string, any> }

    Returns any

PrivateprocessLookupResult

  • processLookupResult(
        result: UsernameLookupResult,
        normalizedUsername: string,
    ): Promise<any>

    Processes lookup result to get complete user data

    Parameters

    • result: UsernameLookupResult
    • normalizedUsername: string

    Returns Promise<any>

put

  • put(path: string, data: any): Promise<GunOperationResult>

    Puts data at the specified path

    Parameters

    • path: string

      Path to store data

    • data: any

      Data to store

    Returns Promise<GunOperationResult>

    Promise resolving to operation result

putUserData

  • putUserData(path: string, data: any): Promise<void>

    Saves user data at the specified path

    Parameters

    • path: string

      Path to save the data (supports nested paths like "test/data/marco")

    • data: any

      Data to save

    Returns Promise<void>

    Promise that resolves when the data is saved

recall

  • recall(): void

    Recall user session

    Returns void

reconnectToPeer

  • reconnectToPeer(peer: string): void

    Reconnects to a specific peer

    Parameters

    • peer: string

      URL of the peer to reconnect

    Returns void

remove

  • remove(path: string): Promise<GunOperationResult>

    Removes data at the specified path

    Parameters

    • path: string

      Path to remove

    Returns Promise<GunOperationResult>

    Promise resolving to operation result

removePeer

  • removePeer(peer: string): void

    Removes a peer from the network

    Parameters

    • peer: string

      URL of the peer to remove

    Returns void

resetPeers

  • resetPeers(newPeers?: string[]): void

    Clears all peers and optionally adds new ones

    Parameters

    • OptionalnewPeers: string[]

      Optional array of new peers to add

    Returns void

resetRateLimit

  • resetRateLimit(): void

    Reset rate limit

    Returns void

PrivateresetRateLimitForUser

  • resetRateLimitForUser(username: string, operation: "login" | "signup"): void

    Resets rate limiting for successful authentication

    Parameters

    • username: string
    • operation: "login" | "signup"

    Returns void

restoreSession

  • restoreSession(): { error?: string; success: boolean; userPub?: string }

    Attempts to restore user session from local storage

    Returns { error?: string; success: boolean; userPub?: string }

    Promise resolving to session restoration result

PrivaterunPostAuthOnAuthResult

  • runPostAuthOnAuthResult(
        username: string,
        userPub: string,
        authResult: any,
    ): Promise<SignUpResult>

    Parameters

    • username: string
    • userPub: string
    • authResult: any

    Returns Promise<SignUpResult>

rx

  • rx(): GunRxJS

    Accesses the RxJS module for reactive programming

    Returns GunRxJS

    GunRxJS instance

PrivatesanitizeUsername

  • sanitizeUsername(username: string): string

    Sanitizes username to prevent path construction issues

    Parameters

    • username: string

      Raw username

    Returns string

    Sanitized username

PrivatesaveCredentials

  • saveCredentials(
        userInfo: { pair: null | ISEAPair; username: string; userPub: string },
    ): void

    Parameters

    • userInfo: { pair: null | ISEAPair; username: string; userPub: string }

    Returns void

saveSession

  • saveSession(session: any): void

    Save session to storage

    Parameters

    • session: any

    Returns void

set

  • set(path: string, data: any): Promise<GunOperationResult>

    Sets data at the specified path

    Parameters

    • path: string

      Path to store data

    • data: any

      Data to store

    Returns Promise<GunOperationResult>

    Promise resolving to operation result

setPasswordHint

  • setPasswordHint(hint: string): void

    Set password hint

    Parameters

    • hint: string

    Returns void

setPasswordHintWithSecurity

  • setPasswordHintWithSecurity(
        username: string,
        password: string,
        hint: string,
        securityQuestions: string[],
        securityAnswers: string[],
    ): Promise<{ error?: string; success: boolean }>

    Sets up security questions and password hint

    Parameters

    • username: string

      Username

    • password: string

      Current password

    • hint: string

      Password hint

    • securityQuestions: string[]

      Array of security questions

    • securityAnswers: string[]

      Array of answers to security questions

    Returns Promise<{ error?: string; success: boolean }>

    Promise resolving with the operation result

setUserData

  • setUserData(data: any): void

    Set user data

    Parameters

    • data: any

    Returns void

setUsername

  • setUsername(username: string): void

    Set username for the current user

    Parameters

    • username: string

    Returns void

signUp

  • signUp(
        username: string,
        password: string,
        pair?: null | ISEAPair,
    ): Promise<SignUpResult>

    Signs up a new user using direct Gun authentication

    Parameters

    • username: string

      Username

    • password: string

      Password

    • Optionalpair: null | ISEAPair

      Optional SEA pair for Web3 login

    Returns Promise<SignUpResult>

    Promise resolving to signup result

PrivatestoreFrozenData

  • storeFrozenData(
        frozenData: any,
        fullPath: string,
        hash: string,
    ): Promise<{ data: any; fullPath: string; hash: string }>

    Stores frozen data in Gun

    Parameters

    • frozenData: any
    • fullPath: string
    • hash: string

    Returns Promise<{ data: any; fullPath: string; hash: string }>

PrivatesubscribeToAuthEvents

  • subscribeToAuthEvents(): void

    Returns void

testConnectivity

  • testConnectivity(): Promise<any>

    Debug method: Tests Gun connectivity and returns status information This is useful for debugging connection issues

    Returns Promise<any>

updateUserAlias

  • updateUserAlias(newAlias: string): Promise<{ error?: string; success: boolean }>

    Updates the user's alias (username) in Gun and saves the updated credentials

    Parameters

    • newAlias: string

      New alias/username to set

    Returns Promise<{ error?: string; success: boolean }>

    Promise resolving to update result

PrivatevalidatePasswordStrength

  • validatePasswordStrength(password: string): { error?: string; valid: boolean }

    Validates password strength according to security requirements

    Parameters

    • password: string

    Returns { error?: string; valid: boolean }

PrivatevalidateSignupCredentials

  • validateSignupCredentials(
        username: string,
        password: string,
        pair?: null | ISEAPair,
    ): { error?: string; valid: boolean }

    Validates signup credentials with enhanced security

    Parameters

    • username: string
    • password: string
    • Optionalpair: null | ISEAPair

    Returns { error?: string; valid: boolean }

verifyFrozenSpace

  • verifyFrozenSpace(
        data: any,
        hash: string,
        namespace?: string,
        path?: string,
    ): Promise<{ error?: string; frozenData?: any; verified: boolean }>

    Verifies if data matches a frozen space entry

    Parameters

    • data: any

      Data to verify

    • hash: string

      Expected hash

    • namespace: string = "default"

      Optional namespace

    • Optionalpath: string

      Optional custom path

    Returns Promise<{ error?: string; frozenData?: any; verified: boolean }>

    Promise resolving to verification result

Settings

Member Visibility

On This Page

Constructors
Properties
Methods
addPeerauthenticateNewUserbuildFrozenPathbuildLoginResultchangeUsernamecheckRateLimitcheckUserExistencecheckUsernameExistsclearGunStorageclearSessioncreateFrozenSpacecreateLookupStrategiescreateNewUsercreateNewUserWithPairdecryptSessionDataderivederiveAllderiveBitcoinderiveEthereumderiveP256emitemitDataEventemitPeerEventencryptSessionDataforgotPasswordgenerateFrozenDataHashgetgetAllConfiguredPeersgetAppScopegetCurrentPeersgetCurrentUsergetDatagetFrozenSpacegetGungetPasswordHintgetPeerInfogetUsergetUserDatagetUsernamegetUserPubinitializeisAuthenticatedisLoggedInleaveloadSessionloginlogoutlookupAlternateKeylookupComprehensiveScanlookupDirectMappinglookupInFrozenSpacenavigateToPathnormalizeUsernamenotifyAuthListenersoffononAuthonceperformAuthenticationprepareFrozenDataprocessLookupResultputputUserDatarecallreconnectToPeerremoveremovePeerresetPeersresetRateLimitresetRateLimitForUserrestoreSessionrunPostAuthOnAuthResultrxsanitizeUsernamesaveCredentialssaveSessionsetsetPasswordHintsetPasswordHintWithSecuritysetUserDatasetUsernamesignUpstoreFrozenDatasubscribeToAuthEventstestConnectivityupdateUserAliasvalidatePasswordStrengthvalidateSignupCredentialsverifyFrozenSpace