Class BeaconWallet

constructor

• new BeaconWallet(options: DAppClientOptions): BeaconWallet

  Creates a BeaconWallet wrapping the singleton Beacon DAppClient.

  Under the covers, Beacon chooses a transport per wallet: browser extensions (such as Temple) use local postMessage, TZIP-10 P2P wallets (such as Kukai web) use Matrix relay nodes (curated by Taquito via matrixNodes), and WalletConnect-enabled wallets (such as Kukai iOS) use WalletConnect v2.

  For WalletConnect support, register your own projectId at https://dashboard.reown.com/ (with your dApp's allowed origins configured) and pass it via options.walletConnectOptions.projectId (typically injected from a frontend build-time environment variable).

  Relying on Beacon's built-in default projectId in production may put your project in breach of the WalletConnect/Reown Terms of Service; that demo-only fallback is deprecated and will be removed in the next minor release of @ecadlabs/beacon-dapp (after which omitting projectId will only disable WalletConnect pairings; extension and Matrix wallets will continue to work).

  Note: BeaconWallet uses getDAppClientInstance(options) under the hood, so all BeaconWallet instances in a page share a single DAppClient singleton (Beacon logs a diagnostic warning if a second instance is constructed with a different name or network).

  Parameters

  • options: DAppClientOptions

  Returns BeaconWallet

client

clearActiveAccount

• clearActiveAccount(): Promise<void>

  Clear the active account without destroying the Beacon session.

  This removes the active account reference from local storage but does not clear other Beacon state such as the cached relay node (beacon:matrix-selected-node) or peer data.

  Use this for switching between accounts within an active session. For a full logout that clears all Beacon storage, use disconnect instead.

  Returns Promise<void>

  See

  disconnect

disconnect

• disconnect(options?: DAppClientDisconnectOptions): Promise<void>

  Disconnect the wallet and clear the active Beacon session.

  This is the recommended way to end a user session (logout). It calls client.disconnect() under the hood, which notifies wallet peers, clears the active account, and tears down the active Beacon transports.

  After calling this method, the BeaconWallet instance can be used to reconnect through a new permission request.

  For switching accounts without a full logout, use clearActiveAccount instead.

  Parameters

  • Optionaloptions: DAppClientDisconnectOptions

  Returns Promise<void>

formatParameters

• formatParameters<T extends ParamsWithOptionalFees>(params: T): T

  Type Parameters

  • T extends ParamsWithOptionalFees

  Parameters

  • params: T

  Returns T

getAccounts

• getAccounts(): Promise<StoredAccountInfo[]>

  Returns all persisted accounts known to the underlying DAppClient.

  Returns Promise<StoredAccountInfo[]>

getActiveAccount

• getActiveAccount(): Promise<StoredAccountInfo | undefined>

  Returns the currently active account from the underlying DAppClient, or undefined when disconnected. Does not throw when uninitialized.

  Returns Promise<StoredAccountInfo | undefined>

getConnectionInfo

• getConnectionInfo(): Promise<ConnectionInfo>

  Returns a non-blocking snapshot of the current transport connection status, health ('ok' | 'degraded'), active relay server, and peer sender ID.

  Returns Promise<ConnectionInfo>

getPeers

• getPeers(): Promise<ExtendedPeerInfo[]>

  Returns all known peers across transports without blocking when no transport is active.

  Returns Promise<ExtendedPeerInfo[]>

getPendingRequests

• getPendingRequests(): readonly PendingRequestInfo[]

  Synchronously returns a read-only snapshot of currently open requests awaiting a wallet response.

  Returns readonly PendingRequestInfo[]

getPK

• getPK(): Promise<string>

  Request the public key from the wallet

  Returns Promise<string>

getPKH

• getPKH(): Promise<string>

  Request the public key hash from the wallet

  Returns Promise<string>

getWalletInfo

• getWalletInfo(): Promise<WalletInfo | undefined>

  Returns resolved metadata (name, optional icon, deeplink, and type) for the active wallet account without initializing a transport or prompting the user, or undefined when disconnected.

  Returns Promise<WalletInfo | undefined>

mapDelegateParamsToWalletParams

• mapDelegateParamsToWalletParams(
      params: () => Promise<WalletDelegateParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletDelegateParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletDelegateParams>

  Returns Promise<RPCOperationWithLimits>

mapFinalizeUnstakeParamsToWalletParams

• mapFinalizeUnstakeParamsToWalletParams(
      params: () => Promise<WalletFinalizeUnstakeParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletFinalizeUnstakeParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletFinalizeUnstakeParams>

  Returns Promise<RPCOperationWithLimits>

mapIncreasePaidStorageWalletParams

• mapIncreasePaidStorageWalletParams(
      params: () => Promise<WalletIncreasePaidStorageParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletIncreasePaidStorageParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletIncreasePaidStorageParams>

  Returns Promise<RPCOperationWithLimits>

mapOriginateParamsToWalletParams

• mapOriginateParamsToWalletParams(
      params: () => Promise<WalletOriginateParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletOriginateParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletOriginateParams>

  Returns Promise<RPCOperationWithLimits>

mapRegisterGlobalConstantParamsToWalletParams

• mapRegisterGlobalConstantParamsToWalletParams(
      params: () => Promise<WalletRegisterGlobalConstantParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletRegisterGlobalConstantParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletRegisterGlobalConstantParams>

  Returns Promise<RPCOperationWithLimits>

mapSmartRollupAddMessagesParamsToWalletParams

• mapSmartRollupAddMessagesParamsToWalletParams(
      params: () => Promise<WalletSmartRollupAddMessagesParams>,
  ): Promise<
      Omit<
          RPCSmartRollupAddMessagesOperation,
          "fee"
          | "gas_limit"
          | "storage_limit",
      > & { fee?: string; gas_limit?: string; storage_limit?: string },
  >

  Map SmartRollupAddMessages parameters for the wallet request.

  Parameters

  • params: () => Promise<WalletSmartRollupAddMessagesParams>

  Returns Promise<
      Omit<
          RPCSmartRollupAddMessagesOperation,
          "fee"
          | "gas_limit"
          | "storage_limit",
      > & { fee?: string; gas_limit?: string; storage_limit?: string },
  >

mapSmartRollupExecuteOutboxMessageParamsToWalletParams

• mapSmartRollupExecuteOutboxMessageParamsToWalletParams(
      params: () => Promise<WalletSmartRollupExecuteOutboxMessageParams>,
  ): Promise<
      Omit<
          RPCSmartRollupOutboxMessageOperation,
          "fee"
          | "gas_limit"
          | "storage_limit",
      > & { fee?: string; gas_limit?: string; storage_limit?: string },
  >

  Map SmartRollupExecuteOutboxMessage parameters for the wallet request.

  Parameters

  • params: () => Promise<WalletSmartRollupExecuteOutboxMessageParams>

  Returns Promise<
      Omit<
          RPCSmartRollupOutboxMessageOperation,
          "fee"
          | "gas_limit"
          | "storage_limit",
      > & { fee?: string; gas_limit?: string; storage_limit?: string },
  >

mapSmartRollupOriginateParamsToWalletParams

• mapSmartRollupOriginateParamsToWalletParams(
      params: () => Promise<WalletSmartRollupOriginateParams>,
  ): Promise<
      Omit<
          RPCSmartRollupOriginateOperation,
          "fee"
          | "gas_limit"
          | "storage_limit",
      > & { fee?: string; gas_limit?: string; storage_limit?: string },
  >

  Map SmartRollupOriginate parameters for the wallet request.

  Parameters

  • params: () => Promise<WalletSmartRollupOriginateParams>

  Returns Promise<
      Omit<
          RPCSmartRollupOriginateOperation,
          "fee"
          | "gas_limit"
          | "storage_limit",
      > & { fee?: string; gas_limit?: string; storage_limit?: string },
  >

mapStakeParamsToWalletParams

• mapStakeParamsToWalletParams(
      params: () => Promise<WalletStakeParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletStakeParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletStakeParams>

  Returns Promise<RPCOperationWithLimits>

mapTransferParamsToWalletParams

• mapTransferParamsToWalletParams(
      params: () => Promise<WalletTransferParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletTransferParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletTransferParams>

  Returns Promise<RPCOperationWithLimits>

mapTransferTicketParamsToWalletParams

• mapTransferTicketParamsToWalletParams(
      params: () => Promise<WalletTransferTicketParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletTransferTicketParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletTransferTicketParams>

  Returns Promise<RPCOperationWithLimits>

mapUnstakeParamsToWalletParams

• mapUnstakeParamsToWalletParams(
      params: () => Promise<WalletUnstakeParams>,
  ): Promise<RPCOperationWithLimits>

  Transform WalletUnstakeParams into a format compliant with the underlying wallet

  Parameters

  • params: () => Promise<WalletUnstakeParams>

  Returns Promise<RPCOperationWithLimits>

removeDefaultParams

• removeDefaultParams(
      params: WalletOperationParams,
      operatedParams: RPCOperationWithLimits,
  ): RPCOperationWithLimits

  Parameters

  • params: WalletOperationParams
  • operatedParams: RPCOperationWithLimits

  Returns RPCOperationWithLimits

requestPermissions

• requestPermissions(
      request?: RequestPermissionInput,
  ): Promise<PermissionResponseOutput>

  Parameters

  • Optionalrequest: RequestPermissionInput

  Returns Promise<PermissionResponseOutput>

sendOperations

• sendOperations(params: any[]): Promise<string>

  Request the wallet to send an operation batch

  Parameters

  • params: any[]

  Returns Promise<string>

setActiveAccount

• setActiveAccount(account?: StoredAccountInfo): Promise<void>

  Sets (or clears, when omitted) the active account on the underlying DAppClient.

  Parameters

  • Optionalaccount: StoredAccountInfo

  Returns Promise<void>

sign

• sign(bytes: string, watermark?: Uint8Array<ArrayBufferLike>): Promise<string>

  Request the wallet to sign a payload

  Parameters

  • bytes: string
  • Optionalwatermark: Uint8Array<ArrayBufferLike>

  Returns Promise<string>

subscribeToEvent

• subscribeToEvent<K extends BeaconEvent>(
      internalEvent: K,
      eventCallback: BeaconEventHandlerFunction<BeaconEventType[K]>,
  ): Promise<() => void>

  Subscribes to a BeaconEvent on the underlying DAppClient and returns an idempotent unsubscribe function.

  Type Parameters

  • K extends BeaconEvent

  Parameters

  • internalEvent: K
  • eventCallback: BeaconEventHandlerFunction<BeaconEventType[K]>

  Returns Promise<() => void>

subscribeToMessages

• subscribeToMessages(listener: (record: BeaconMessageRecord) => void): () => void

  Subscribes to immutable plaintext Beacon protocol message snapshots (direction: 'incoming' | 'outgoing', transport, senderId, ts, message, and optional incoming routing disposition) and returns an idempotent unsubscribe function.

  Parameters

  • listener: (record: BeaconMessageRecord) => void

  Returns () => void