Class WalletConnect<Methods>

constructor

• new WalletConnect<Methods extends TWalletMethod = CommonWalletMethods>(
      options: WalletConnectOptions,
  ): WalletConnect<Methods>

  Type Parameters

  • Methods extends TWalletMethod = CommonWalletMethods

  Parameters

  • options: WalletConnectOptions

  Returns WalletConnect<Methods>

acceptRelayHint

defaultTimeout

encryption$

notifications$

Readonlysecret

service$

support$

Staticpool

StaticpublishMethod

StaticsubscriptionMethod

relays

• get relays(): string[]

  Returns string[]

service

• get service(): string | undefined

  Returns string | undefined

call

• call<K extends string>(
      method: K,
      params: Extract<Methods, { method: K }>["request"]["params"],
      options?: { timeout?: number },
  ): Observable<
      | Extract<Methods, { method: K }>["response"]
      | Extract<Methods, { method: K }>["error"],
  >

  Call a method and return an observable of results

  Type Parameters

  • K extends string

  Parameters

  • method: K
  • params: Extract<Methods, { method: K }>["request"]["params"]
  • options: { timeout?: number } = {}

  Returns Observable<
      | Extract<Methods, { method: K }>["response"]
      | Extract<Methods, { method: K }>["error"],
  >

genericCall

• genericCall<Method extends TWalletMethod>(
      method: Method["method"],
      params: Method["request"]["params"],
      options?: { timeout?: number },
  ): Observable<Method["response"] | Method["error"]>

  Generic call method with generic type

  Type Parameters

  • Method extends TWalletMethod

  Parameters

  • method: Method["method"]
  • params: Method["request"]["params"]
  • options: { timeout?: number } = {}

  Returns Observable<Method["response"] | Method["error"]>

genericRequest

• genericRequest<Method extends TWalletMethod>(
      method: Method["method"],
      params: Method["request"]["params"],
      options?: { timeout?: number },
  ): Promise<Method["response"]["result"]>

  Request method with generic type

  Type Parameters

  • Method extends TWalletMethod

  Parameters

  • method: Method["method"]
  • params: Method["request"]["params"]
  • options: { timeout?: number } = {}

  Returns Promise<Method["response"]["result"]>

getAuthURI

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

  Gets the nostr+walletauth URI for the connection

  Parameters

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

  Returns string

getBalance

• getBalance(): Promise<{ balance: number }>

  Get wallet balance

  Returns Promise<{ balance: number }>

getInfo

• getInfo(): Promise<Helpers.WalletInfo>

  Get wallet info

  Returns Promise<Helpers.WalletInfo>

getSupport

• getSupport(): Promise<WalletSupport<TWalletMethod> | null>

  Get the wallet support info

  Returns Promise<WalletSupport<TWalletMethod> | null>

listTransactions

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

  List transactions

  Parameters

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

  Returns Promise<{ transactions: Transaction[] }>

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<
          {
              amount: number;
              description?: string;
              description_hash?: string;
              expiry?: number;
          },
          "amount",
      >,
  ): Promise<Transaction>

  Create a new invoice

  Parameters

  • amount: number
  • Optionaloptions: Omit<
        {
            amount: number;
            description?: string;
            description_hash?: string;
            expiry?: number;
        },
        "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<{ fees_paid?: number; preimage: string }>

  Pay a lightning invoice

  Parameters

  • invoice: string
  • Optionalamount: number

  Returns Promise<{ fees_paid?: number; preimage: string }>

payKeysend

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

  Send a keysend payment

  Parameters

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

  Returns Promise<{ fees_paid?: number; preimage: string }>

payMultipleInvoices

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

  Pay multiple lightning invoices

  Parameters

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

  Returns Promise<{ fees_paid?: number; preimage: string }[]>

payMultipleKeysend

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

  Send multiple keysend payments

  Parameters

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

  Returns Promise<{ fees_paid?: number; preimage: string }[]>

request

• request<K extends string>(
      method: K,
      params: Extract<Methods, { method: K }>["request"]["params"],
      options?: { timeout?: number },
  ): Promise<Extract<Methods, { method: K }>["response"]["result"]>

  Typed request method, returns the result or throws and error

  Type Parameters

  • K extends string

  Parameters

  • method: K
  • params: Extract<Methods, { method: K }>["request"]["params"]
  • options: { timeout?: number } = {}

  Returns Promise<Extract<Methods, { method: K }>["response"]["result"]>

supportsMethod

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

  Check if the wallet supports a method

  Parameters

  • method: string

  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<Methods extends TWalletMethod = CommonWalletMethods>(
      connectionString: string,
      options?: Omit<WalletConnectOptions, "secret" | "service" | "relays">,
  ): WalletConnect<Methods>

  Create a new WalletConnect instance from a connection string

  Type Parameters

  • Methods extends TWalletMethod = CommonWalletMethods

  Parameters

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

  Returns WalletConnect<Methods>

StaticfromJSON

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

  Create a new WalletConnect instance from a serialized object

  Parameters

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

  Returns WalletConnect