Class NwcPaymentsProcessor

src/payments-processors/nwc-payments-processor.ts:91–243

}

export class NwcPaymentsProcessor implements IPaymentsProcessor {
  public constructor(
    private nwcUrl: string,
    private replyTimeoutMs: number,
    private settings: Factory<Settings>,
  ) {}

  private withReplyTimeout = async <T>(operation: Promise<T>): Promise<T> => {
    const controller = new AbortController()
    const timeout = sleep(this.replyTimeoutMs, undefined, {
      ref: false,
      signal: controller.signal,
    })
      .then(() => {
        throw new nwc.Nip47ReplyTimeoutError(`reply timeout after ${this.replyTimeoutMs}ms`, 'INTERNAL')
      })
      .catch((error) => {
        if ((error as Error).name === 'AbortError') {
          return undefined as never
        }

        throw error
      })

    try {
      return await Promise.race([operation, timeout])
    } finally {
      controller.abort()
    }
  }

  private withClient = async <T>(fn: (client: nwc.NWCClient) => Promise<T>): Promise<T> => {
    const client = new nwc.NWCClient({ nostrWalletConnectUrl: this.nwcUrl })
    let caughtError: unknown

    try {
      return await fn(client)
    } catch (error) {
      caughtError = error
      throw error
    } finally {
      if (caughtError instanceof nwc.Nip47ReplyTimeoutError) {
        // The SDK can still emit a late response; this wait must not keep the process alive.
        await sleep(this.replyTimeoutMs + 100, undefined, { ref: false })
      }
      client.close()
    }
  }

  public async getInvoice(invoiceOrId: string | Invoice): Promise<GetInvoiceResponse> {
    const invoiceId = typeof invoiceOrId === 'string' ? invoiceOrId : invoiceOrId.id
    logger('get invoice: %s', invoiceId)

    try {
      return await this.withClient(async (client) => {
        const transaction = (await this.withReplyTimeout(
          client.lookupInvoice({ payment_hash: invoiceId }),
        )) as NwcTransaction