Class SessionKeyManager

constructor

• new SessionKeyManager(
      config: SessionKeyConfig,
      ui?: UserInterface,
  ): SessionKeyManager

  Parameters

  • config: SessionKeyConfig
  • Optionalui: UserInterface

  Returns SessionKeyManager

config

Optionalui

whitelist

checkExistingSessionKey

• checkExistingSessionKey(
      session: Session,
  ): Promise<
      { exists: boolean; mismatch?: SessionKeyMismatch; permission?: Name },
  >

  Check if a session key permission exists on-chain and validate its whitelist.

  Parameters

  • session: Session

    The session to check

  Returns Promise<{ exists: boolean; mismatch?: SessionKeyMismatch; permission?: Name }>

  Object with exists flag, permission name, and optional mismatch details

fetchPermission

• fetchPermission(
      client: APIClient,
      account: Name,
      permission: Name,
  ): Promise<AccountPermission | undefined>

  Fetch permission data from the blockchain. Uses custom fetchPermission function if provided in config, otherwise uses default implementation.

  Parameters

  • client: APIClient

    API client to use for fetching

  • account: Name

    Account name

  • permission: Name

    Permission name

  Returns Promise<AccountPermission | undefined>

  Permission data or undefined if not found

getPermissionName

• getPermissionName(appName?: string): Name

  Get the permission name for the session key. Uses config.permission if set, otherwise generates from app name or defaults to 'sessionkey'.

  Parameters

  • OptionalappName: string

    Optional application name to generate permission from

  Returns Name

  The permission name

hasSessionKey

• hasSessionKey(
      session: Session,
  ): session is Session & { walletPlugin: SessionKeyWalletInterface }

  Type guard to check if a session has an active session key wallet.

  Parameters

  • session: Session

    The session to check

  Returns session is Session & { walletPlugin: SessionKeyWalletInterface }

  True if the session has a session key wallet

isWhitelisted

• isWhitelisted(action: AnyAction): boolean

  Check if an action is whitelisted for signing with the session key.

  Parameters

  • action: AnyAction

    The action to check

  Returns boolean

  True if the action is whitelisted

remove

• remove(session: Session): Promise<void>

  Remove the session key from the given session. Removes the key from on-chain permission and unlinks/deletes as needed.

  Parameters

  • session: Session

    The session to remove the session key from

  Returns Promise<void>

  Throws

  If the session does not have an active session key

  Throws

  If the permission or key is not found on-chain

setup

• setup(
      session: Session,
      onConflict?: (
          existingKeys: KeyWeight[],
      ) => Promise<SessionKeyConflictChoice>,
  ): Promise<SessionKeySetupResult>

  Set up a new session key for the given session. Generates a new K1 key, creates the permission on-chain, and wraps the session wallet.

  Parameters

  • session: Session

    The session to set up a session key for

  • OptionalonConflict: (existingKeys: KeyWeight[]) => Promise<SessionKeyConflictChoice>

    Optional callback if the permission already exists with other keys

  Returns Promise<SessionKeySetupResult>

  The public key and permission name of the created session key

  Throws

  If the session already has an active session key

updateLinks

• updateLinks(session: Session): Promise<void>

  Update the on-chain linkauth actions to match the current whitelist. Removes extra links and adds missing links to synchronize state.

  Parameters

  • session: Session

    The session with an active session key

  Returns Promise<void>

  Throws

  If the session does not have an active session key

validateWhitelist

• validateWhitelist(session: Session): Promise<SessionKeyMismatch | undefined>

  Validate that the session's whitelist matches the on-chain linked actions.

  Parameters

  • session: Session

    The session with an active session key to validate

  Returns Promise<SessionKeyMismatch | undefined>

  Mismatch details if whitelist differs from on-chain state, undefined if they match