How to use the bolt11.decode function in bolt11

async getUserInvoices() {
    let range = await this._redis.lrange('userinvoices_for_' + this._userid, 0, -1);
    let result = [];
    for (let invoice of range) {
      invoice = JSON.parse(invoice);
      let decoded = lightningPayReq.decode(invoice.payment_request);
      invoice.description = '';
      for (let tag of decoded.tags) {
        if (tag.tagName === 'description') {
          invoice.description += decodeURIComponent(tag.data);
        }
        if (tag.tagName === 'payment_hash') {
          invoice.payment_hash = tag.data;
        }
      }

      invoice.ispaid = _invoice_ispaid_cache[invoice.payment_hash] || !!(await this.getPaymentHashPaid(invoice.payment_hash));
      if (!invoice.ispaid) {
        if (decoded && decoded.timestamp > ((+new Date()) / 1000 - 3600 * 24 * 5)) {
          // if invoice is not too old we query lnd to find out if its paid
          let lookup_info = await this.lookupInvoice(invoice.payment_hash);
          invoice.ispaid = lookup_info.settled; // TODO: start using `state` instead as its future proof, and this one might get deprecated

module.exports = ({invoice}, cbk) => {
  if (!invoice) {
    return cbk([0, 'Expected invoice']);
  }

  try {
    const {tags} = decode(invoice);

    const [paymentHashTag] = tags.filter(t => t.tagName === 'payment_hash');

    return cbk(null, {id: paymentHashTag.data});
  } catch (e) {
    return cbk([0, 'Error parsing invoice', e]);
  }
};

export const isLn = (input, chain = 'bitcoin', network = 'mainnet') => {
  if (!input || typeof input !== 'string') {
    return false
  }
  try {
    const decoded = lightningRequestReq.decode(input)
    if (decoded.coinType !== get(coinTypes, `${chain}.${network}`)) {
      throw new Error('Invalid coin type')
    }
    return true
  } catch (e) {
    return false
  }
}

async saveUserInvoice(doc) {
    let decoded = lightningPayReq.decode(doc.payment_request);
    let payment_hash;
    for (let tag of decoded.tags) {
      if (tag.tagName === 'payment_hash') {
        payment_hash = tag.data;
      }
    }

    await this._redis.set('payment_hash_' + payment_hash, this._userid);
    return await this._redis.rpush('userinvoices_for_' + this._userid, JSON.stringify(doc));
  }

export const decodePayReq = (payReq, addDefaults = true) => {
  const data = lightningRequestReq.decode(payReq)
  const expiry = getTag(data, 'expire_time')
  if (addDefaults && !expiry) {
    data.tags.push({
      tagName: 'expire_time',
      data: 3600,
    })
    data.timeExpireDate = data.timestamp + 3600
    data.timeExpireDateString = new Date(data.timeExpireDate * 1000).toISOString()
  }
  return data
}

export const decodePayReq = (payReq, addDefaults = true) => {
  const data = lightningRequestReq.decode(payReq)
  const expiry = data.tags.find(t => t.tagName === 'expire_time')
  if (addDefaults && !expiry) {
    data.tags.push({
      tagName: 'expire_time',
      data: 3600,
    })
    data.timeExpireDate = data.timestamp + 3600
    data.timeExpireDateString = new Date(data.timeExpireDate * 1000).toISOString()
  }
  return data
}

export const isLn = (input, chain = 'bitcoin', network = 'mainnet') => {
  if (!input || typeof input !== 'string') {
    return false
  }
  try {
    const decoded = lightningRequestReq.decode(input)
    if (decoded.coinType !== get(coinTypes, `${chain}.${network}`)) {
      throw new Error('Invalid coin type')
    }
    return true
  } catch (e) {
    return false
  }
}

decodePayReqLocally(payReq) {
    this._decoded_locally = lightningPayReq.decode(payReq);
  }