Class ShogunCore

constructor

• new ShogunCore(config: ShogunCoreConfig): ShogunCore

  Initialize the Shogun SDK

  Parameters

  • config: ShogunCoreConfig

    SDK Configuration object

  Returns ShogunCore

  Description

  Creates a new instance of ShogunCore with the provided configuration. Initializes all required components including storage, event emitter, GunInstance connection, and plugin system.

config

db

Optionalprovider

rx

storage

wallets

Static ReadonlyAPI_VERSION

gun

• get gun(): IGunInstance<any>

  Access to the Gun instance

  Returns IGunInstance<any>

  The Gun instance

user

• get user(): null | IGunUserInstance<any, any, any, any>

  Access to the current user

  Returns null | IGunUserInstance<any, any, any, any>

  The current Gun user instance

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

checkPluginCompatibility

• checkPluginCompatibility(): {
      compatible: { name: string; version: string }[];
      incompatible: { name: string; reason: string; version: string }[];
      unknown: { name: string; version: string }[];
  }

  Check plugin compatibility with current ShogunCore version

  Returns {
      compatible: { name: string; version: string }[];
      incompatible: { name: string; reason: string; version: string }[];
      unknown: { name: string; version: string }[];
  }

  Object with compatibility information

emit

• emit<K extends keyof ShogunEventMap>(
      eventName: K,
      data?: ShogunEventMap[K] extends void ? never : ShogunEventMap[K],
  ): boolean

  Emits an event through the core's event emitter. Plugins should use this method to emit events instead of accessing the private eventEmitter directly.

  Type Parameters

  • K extends keyof ShogunEventMap

  Parameters

  • eventName: K

    The name of the event to emit.
  • Optionaldata: ShogunEventMap[K] extends void ? never : ShogunEventMap[K]

    The data to pass with the event.

  Returns boolean

  Indicates if the event had listeners.

getAuthenticationMethod

• getAuthenticationMethod(
      type: AuthMethod,
  ):
      | undefined
      | ShogunPlugin
      | {
          login: (username: string, password: string) => Promise<AuthResult>;
          signUp: (
              username: string,
              password: string,
              confirm?: string,
          ) => Promise<SignUpResult>;
      }

  Get an authentication method plugin by type

  Parameters

  • type: AuthMethod

    The type of authentication method

  Returns
      | undefined
      | ShogunPlugin
      | {
          login: (username: string, password: string) => Promise<AuthResult>;
          signUp: (
              username: string,
              password: string,
              confirm?: string,
          ) => Promise<SignUpResult>;
      }

  The authentication plugin or undefined if not available This is a more modern approach to accessing authentication methods

getAuthMethod

• getAuthMethod(): undefined | AuthMethod

  Get the current authentication method

  Returns undefined | AuthMethod

  The current authentication method or undefined if not set

getCurrentUser

• getCurrentUser(): null | { pub: string; user?: any }

  Gets the current user information

  Returns null | { pub: string; user?: any }

  Current user object or null

getIsLoggedIn

• getIsLoggedIn(): boolean

  Returns boolean

getPlugin

• getPlugin<T = ShogunPlugin>(name: string): undefined | T

  Retrieve a registered plugin by name

  Type Parameters

  • T = ShogunPlugin

    Type of the plugin or its public interface

  Parameters

  • name: string

    Name of the plugin

  Returns undefined | T

  The requested plugin or undefined if not found

getPluginCount

• getPluginCount(): number

  Get the total number of registered plugins

  Returns number

  Number of registered plugins

getPluginsByCategory

• getPluginsByCategory(category: PluginCategory): ShogunPlugin[]

  Get all plugins of a specific category

  Parameters

  • category: PluginCategory

    Category of plugins to filter

  Returns ShogunPlugin[]

  Array of plugins in the specified category

getPluginsInfo

• getPluginsInfo(): {
      category?: PluginCategory;
      description?: string;
      name: string;
      version: string;
  }[]

  Get information about all registered plugins

  Returns {
      category?: PluginCategory;
      description?: string;
      name: string;
      version: string;
  }[]

  Array of plugin information objects

getPluginsInitializationStatus

• getPluginsInitializationStatus(): Record<
      string,
      { error?: string; initialized: boolean },
  >

  Check if all plugins are properly initialized

  Returns Record<string, { error?: string; initialized: boolean }>

  Object with initialization status for each plugin

getPluginSystemDebugInfo

• getPluginSystemDebugInfo(): {
      compatibility: {
          compatible: { name: string; version: string }[];
          incompatible: { name: string; reason: string; version: string }[];
          unknown: { name: string; version: string }[];
      };
      initializationStatus: Record<
          string,
          { error?: string; initialized: boolean },
      >;
      plugins: {
          category?: PluginCategory;
          description?: string;
          error?: string;
          initialized: boolean;
          name: string;
          version: string;
      }[];
      shogunCoreVersion: string;
      totalPlugins: number;
      validation: {
          failedPlugins: string[];
          initializedPlugins: number;
          totalPlugins: number;
          warnings: string[];
      };
  }

  Get comprehensive debug information about the plugin system

  Returns {
      compatibility: {
          compatible: { name: string; version: string }[];
          incompatible: { name: string; reason: string; version: string }[];
          unknown: { name: string; version: string }[];
      };
      initializationStatus: Record<
          string,
          { error?: string; initialized: boolean },
      >;
      plugins: {
          category?: PluginCategory;
          description?: string;
          error?: string;
          initialized: boolean;
          name: string;
          version: string;
      }[];
      shogunCoreVersion: string;
      totalPlugins: number;
      validation: {
          failedPlugins: string[];
          initializedPlugins: number;
          totalPlugins: number;
          warnings: string[];
      };
  }

  Complete plugin system debug information

getRecentErrors

• getRecentErrors(count?: number): ShogunError[]

  Retrieve recent errors logged by the system

  Parameters

  • count: number = 10

    Number of errors to retrieve (default: 10)

  Returns ShogunError[]

  List of most recent errors

hasPlugin

• hasPlugin(name: string): boolean

  Check if a plugin is registered

  Parameters

  • name: string

    Name of the plugin to check

  Returns boolean

  true if the plugin is registered, false otherwise

initialize

• initialize(): Promise<void>

  Initialize the Shogun SDK asynchronously This method handles initialization tasks that require async operations

  Returns Promise<void>

isLoggedIn

• isLoggedIn(): boolean

  Check if user is logged in

  Returns boolean

  True if user is logged in, false otherwise

  Description

  Verifies authentication status by checking GunInstance login state and presence of authentication credentials in storage

login

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

  Authenticate user with username and password

  Parameters

  • username: string

    Username
  • password: string

    User password
  • Optionalpair: null | ISEAPair

  Returns Promise<AuthResult>

  Promise with authentication result

  Description

  Attempts to log in user with provided credentials. Emits login event on success.

loginWithPair

• loginWithPair(pair: ISEAPair): Promise<AuthResult>

  Login with GunDB pair directly

  Parameters

  • pair: ISEAPair

    GunDB SEA pair for authentication

  Returns Promise<AuthResult>

  Promise with authentication result

  Description

  Authenticates user using a GunDB pair directly. Emits login event on success.

logout

• logout(): void

  Perform user logout

  Returns void

  Description

  Logs out the current user from GunInstance and emits logout event. If user is not authenticated, the logout operation is ignored.

off

• off<K extends keyof ShogunEventMap>(
      eventName: K,
      listener: ShogunEventMap[K] extends void
          ? () => void
          : (data: ShogunEventMap[K]) => void,
  ): this

  Remove an event listener

  Type Parameters

  • K extends keyof ShogunEventMap

  Parameters

  • eventName: K

    The name of the event to stop listening for
  • listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void

    The callback function to remove

  Returns this

  Returns this instance for method chaining

on

• on<K extends keyof ShogunEventMap>(
      eventName: K,
      listener: ShogunEventMap[K] extends void
          ? () => void
          : (data: ShogunEventMap[K]) => void,
  ): this

  Add an event listener

  Type Parameters

  • K extends keyof ShogunEventMap

  Parameters

  • eventName: K

    The name of the event to listen for
  • listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void

    The callback function to execute when the event is emitted

  Returns this

  Returns this instance for method chaining

once

• once<K extends keyof ShogunEventMap>(
      eventName: K,
      listener: ShogunEventMap[K] extends void
          ? () => void
          : (data: ShogunEventMap[K]) => void,
  ): this

  Add a one-time event listener

  Type Parameters

  • K extends keyof ShogunEventMap

  Parameters

  • eventName: K

    The name of the event to listen for
  • listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void

    The callback function to execute when the event is emitted

  Returns this

  Returns this instance for method chaining

register

• register(plugin: ShogunPlugin): void

  Registers a plugin with the Shogun SDK

  Parameters

  • plugin: ShogunPlugin

    Plugin instance to register

  Returns void

  Throws

  Error if a plugin with the same name is already registered

reinitializeFailedPlugins

• reinitializeFailedPlugins(): {
      failed: { error: string; name: string }[];
      success: string[];
  }

  Attempt to reinitialize failed plugins

  Returns { failed: { error: string; name: string }[]; success: string[] }

  Object with reinitialization results

removeAllListeners

• removeAllListeners(eventName?: string | symbol): this

  Remove all listeners for a specific event or all events

  Parameters

  • OptionaleventName: string | symbol

    Optional. The name of the event to remove listeners for. If not provided, all listeners for all events are removed.

  Returns this

  Returns this instance for method chaining

saveCredentials

• saveCredentials(credentials: any): Promise<void>

  Saves the current user credentials to storage

  Parameters

  • credentials: any

  Returns Promise<void>

setAuthMethod

• setAuthMethod(method: AuthMethod): void

  Set the current authentication method This is used by plugins to indicate which authentication method was used

  Parameters

  • method: AuthMethod

    The authentication method used

  Returns void

signUp

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

  Register a new user with provided credentials

  Parameters

  • username: string

    Username
  • password: string = ""

    Password
  • email: string = ""
  • Optionalpair: null | ISEAPair

    Pair of keys

  Returns Promise<SignUpResult>

  Registration result

  Description

  Creates a new user account with the provided credentials. Validates password requirements and emits signup event on success.

unregister

• unregister(pluginName: string): void

  Unregisters a plugin from the Shogun SDK

  Parameters

  • pluginName: string

    Name of the plugin to unregister

  Returns void

validatePluginSystem

• validatePluginSystem(): {
      failedPlugins: string[];
      initializedPlugins: number;
      totalPlugins: number;
      warnings: string[];
  }

  Validate plugin system integrity

  Returns {
      failedPlugins: string[];
      initializedPlugins: number;
      totalPlugins: number;
      warnings: string[];
  }

  Object with validation results