Class WalletConnect

constructor

• new WalletConnect(options: WalletConnectOptions): WalletConnect

  Parameters

  • options: WalletConnectOptions

  Returns WalletConnect

defaultTimeout

encryption$

notifications$

Readonlyrelays

Readonlysecret

service$

support$

Staticpool

StaticpublishMethod

StaticsubscriptionMethod

service

• get service(): undefined | string

  Returns undefined | string

getAuthURI

• getAuthURI(parts?: Omit<WalletAuthURI, "client" | "relays">): string

  Gets the nostr+walletauth URI for the connection

  Parameters

  • Optionalparts: Omit<WalletAuthURI, "client" | "relays">

  Returns string

getBalance

• getBalance(): Promise<GetBalanceResult>

  Get wallet balance

  Returns Promise<GetBalanceResult>

getInfo

• getInfo(): Promise<GetInfoResult>

  Get wallet info

  Returns Promise<GetInfoResult>

getSupport

• getSupport(): Promise<null | WalletSupport>

  Get the wallet support info

  Returns Promise<null | WalletSupport>

listTransactions

• listTransactions(
      params?: {
          from?: number;
          limit?: number;
          offset?: number;
          type?: "incoming" | "outgoing";
          unpaid?: boolean;
          until?: number;
      },
  ): Promise<ListTransactionsResult>

  List transactions

  Parameters

  • Optionalparams: {
        from?: number;
        limit?: number;
        offset?: number;
        type?: "incoming" | "outgoing";
        unpaid?: boolean;
        until?: number;
    }

  Returns Promise<ListTransactionsResult>

lookupInvoice

• lookupInvoice(payment_hash?: string, invoice?: string): Promise<Transaction>

  Look up an invoice by payment hash or invoice string

  Parameters

  • Optionalpayment_hash: string
  • Optionalinvoice: string

  Returns Promise<Transaction>

makeInvoice

• makeInvoice(
      amount: number,
      options?: Omit<MakeInvoiceParams, "amount">,
  ): Promise<Transaction>

  Create a new invoice

  Parameters

  • amount: number
  • Optionaloptions: Omit<MakeInvoiceParams, "amount">

  Returns Promise<Transaction>

notification

• notification<T extends WalletNotification>(
      type: T["notification_type"],
      listener: (notification: T["notification"]) => any,
  ): Subscription

  Listen for a type of notification

  Type Parameters

  • T extends WalletNotification

  Parameters

  • type: T["notification_type"]
  • listener: (notification: T["notification"]) => any

  Returns Subscription

  a method to unsubscribe the listener

payInvoice

• payInvoice(invoice: string, amount?: number): Promise<PayInvoiceResult>

  Pay a lightning invoice

  Parameters

  • invoice: string
  • Optionalamount: number

  Returns Promise<PayInvoiceResult>

payKeysend

• payKeysend(
      pubkey: string,
      amount: number,
      preimage?: string,
      tlv_records?: { type: number; value: string }[],
  ): Promise<PayKeysendResult>

  Send a keysend payment

  Parameters

  • pubkey: string
  • amount: number
  • Optionalpreimage: string
  • Optionaltlv_records: { type: number; value: string }[]

  Returns Promise<PayKeysendResult>

payMultipleInvoices

• payMultipleInvoices(
      invoices: { amount?: number; id?: string; invoice: string }[],
  ): Promise<PayInvoiceResult[]>

  Pay multiple lightning invoices

  Parameters

  • invoices: { amount?: number; id?: string; invoice: string }[]

  Returns Promise<PayInvoiceResult[]>

payMultipleKeysend

• payMultipleKeysend(
      keysends: {
          amount: number;
          id?: string;
          preimage?: string;
          pubkey: string;
          tlv_records?: { type: number; value: string }[];
      }[],
  ): Promise<PayKeysendResult[]>

  Send multiple keysend payments

  Parameters

  • keysends: {
        amount: number;
        id?: string;
        preimage?: string;
        pubkey: string;
        tlv_records?: { type: number; value: string }[];
    }[]

  Returns Promise<PayKeysendResult[]>

request

• request(
      request: WalletRequest,
      options?: { timeout?: number },
  ): Observable<WalletResponse>

  Core RPC method that makes a request and returns the response

  Parameters

  • request: WalletRequest
  • options: { timeout?: number } = {}

  Returns Observable<WalletResponse>

supportsMethod

• supportsMethod(method: WalletMethod): Promise<boolean>

  Check if the wallet supports a method

  Parameters

  • method: WalletMethod

  Returns Promise<boolean>

supportsNotifications

• supportsNotifications(): Promise<boolean>

  Check if the wallet supports notifications

  Returns Promise<boolean>

supportsNotificationType

• supportsNotificationType(type: NotificationType): Promise<boolean>

  Check if the wallet supports a notification type

  Parameters

  • type: NotificationType

  Returns Promise<boolean>

toJSON

• toJSON(): WalletConnectURI

  Serialize the WalletConnect instance

  Returns WalletConnectURI

waitForService

• waitForService(abortSignal?: AbortSignal): Promise<string>

  Wait for the wallet service to connect

  Parameters

  • OptionalabortSignal: AbortSignal

  Returns Promise<string>

StaticfromConnectURI

• fromConnectURI(
      connectionString: string,
      options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">,
  ): WalletConnect

  Create a new WalletConnect instance from a connection string

  Parameters

  • connectionString: string
  • Optionaloptions: Omit<WalletConnectOptions, "secret" | "relays" | "service">

  Returns WalletConnect

StaticfromJSON

• fromJSON(
      json: WalletConnectURI,
      options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">,
  ): WalletConnect

  Create a new WalletConnect instance from a serialized object

  Parameters

  • json: WalletConnectURI
  • Optionaloptions: Omit<WalletConnectOptions, "secret" | "relays" | "service">

  Returns WalletConnect