# List currently open channel with routing and uptime information.

$ frcli insights [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.ChannelInsightsRequest()
>>> response = stub.ChannelInsights(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "channel_insights": <array ChannelInsight>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = {}
faradayServer.channelInsights(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "channel_insights": <array ChannelInsight>,
//  }

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.CloseReportRequest(
        channel_point=<string>,
    )
>>> response = stub.CloseReport(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "channel_point": <string>,
    "channel_initiator": <bool>,
    "close_type": <string>,
    "close_txid": <string>,
    "open_fee": <string>,
    "close_fee": <string>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = { 
  channel_point: <string>, 
};
faradayServer.closeReport(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "channel_point": <string>,
//      "channel_initiator": <bool>,
//      "close_type": <string>,
//      "close_txid": <string>,
//      "open_fee": <string>,
//      "close_fee": <string>,
//  }

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.ExchangeRateRequest(
        timestamps=<array uint64>,
        granularity=<Granularity>,
        fiat_backend=<FiatBackend>,
        custom_prices=<array BitcoinPrice>,
    )
>>> response = stub.ExchangeRate(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "rates": <array ExchangeRate>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = { 
  timestamps: <array uint64>, 
  granularity: <Granularity>, 
  fiat_backend: <FiatBackend>, 
  custom_prices: <array BitcoinPrice>, 
};
faradayServer.exchangeRate(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "rates": <array ExchangeRate>,
//  }

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.NodeAuditRequest(
        start_time=<uint64>,
        end_time=<uint64>,
        disable_fiat=<bool>,
        granularity=<Granularity>,
        custom_categories=<array CustomCategory>,
        fiat_backend=<FiatBackend>,
        custom_prices=<array BitcoinPrice>,
    )
>>> response = stub.NodeAudit(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "reports": <array ReportEntry>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = { 
  start_time: <uint64>, 
  end_time: <uint64>, 
  disable_fiat: <bool>, 
  granularity: <Granularity>, 
  custom_categories: <array CustomCategory>, 
  fiat_backend: <FiatBackend>, 
  custom_prices: <array BitcoinPrice>, 
};
faradayServer.nodeAudit(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "reports": <array ReportEntry>,
//  }

# Get close recommendations for currently open channels based on whether it is an outlier.

$ frcli outliers [command options] [arguments...]

# --outlier_mult value   (optional with outlier strategy) Number of inter quartile ranges a channel should be from quartiles to be considered an outlier. Recommended values are 1.5 for aggressive recommendations and 3 for conservative ones.
# --uptime               set to get recommendations based on the channel's peer's ratio of uptime to time monitored
# --revenue              get recommendations based on the channel's revenue per confirmation
# --incoming_volume      get recommendations based on the channel's incoming volume per confirmation
# --outgoing_volume      get recommendations based on the channel's outgoing volume per confirmation
# --volume               get recommendations based on the channel's total volume per confirmation
# --min_monitored value  amount of time in seconds a channel should be monitored for to be eligible for close (default: 2419200)

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.OutlierRecommendationsRequest(
        rec_request=<CloseRecommendationRequest>,
        outlier_multiplier=<float>,
    )
>>> response = stub.OutlierRecommendations(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "total_channels": <int32>,
    "considered_channels": <int32>,
    "recommendations": <array Recommendation>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = { 
  rec_request: <CloseRecommendationRequest>, 
  outlier_multiplier: <float>, 
};
faradayServer.outlierRecommendations(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "total_channels": <int32>,
//      "considered_channels": <int32>,
//      "recommendations": <array Recommendation>,
//  }

# Get a pairwise revenue report for a channel.

$ frcli revenue [command options] [arguments...]

# --chan_points value  (optional) A set of channels to generate a revenue report for. If not specified, reports will be created for all channels that forwarded payments over the period provided. A single channel can be set directly using --chan_points=txid:outpoint,multiple channels should be specified usinga comma separated list in braces --chan_points={chan, chan}
# --start_time value   (optional) The unix timestamp in seconds from which the report should be generated.If not set, the report will be generated from the time of channel open. (default: 0)
# --end_time value     (optional) The unix timestamp in secondsuntil which the report should be generated.If not set, the report will be produced until the present. (default: 0)

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.RevenueReportRequest(
        chan_points=<array string>,
        start_time=<uint64>,
        end_time=<uint64>,
    )
>>> response = stub.RevenueReport(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "reports": <array RevenueReport>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = { 
  chan_points: <array string>, 
  start_time: <uint64>, 
  end_time: <uint64>, 
};
faradayServer.revenueReport(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "reports": <array RevenueReport>,
//  }

# Get close recommendations for currently open channels based on whether they are below a set threshold.

$ frcli threshold [command options] [arguments...]

# --uptime value         Ratio of uptime to time monitored, expressed in [0;1]. (default: 0)
# --revenue value        threshold revenue (in msat) per confirmation beneath which channels will be identified for close. (default: 0)
# --incoming value       threshold incoming volume (in msat) per confirmation beneath which channels will be identified for close (default: 0)
# --outgoing value       threshold outgoing volume (in msat) per confirmation beneath which channels will be identified for close (default: 0)
# --volume value         threshold total volume (in msat) per confirmation beneath which channels will be identified for close (default: 0)
# --min_monitored value  amount of time in seconds a channel should be monitored for to be eligible for close (default: 2419200)

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the frdrpc/faraday.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import faraday_pb2 as frdrpc, faraday_pb2_grpc as faradaystub
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('FARADAY_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:8465', ssl_creds)
>>> stub = faradaystub.FaradayServerStub(channel)
>>> request = frdrpc.ThresholdRecommendationsRequest(
        rec_request=<CloseRecommendationRequest>,
        threshold_value=<float>,
    )
>>> response = stub.ThresholdRecommendations(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "total_channels": <int32>,
    "considered_channels": <int32>,
    "recommendations": <array Recommendation>,
}

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('faraday.proto', loaderOptions);
const frdrpc = grpc.loadPackageDefinition(packageDefinition).frdrpc;
const macaroon = fs.readFileSync("FARADAY_DIR/regtest/faraday.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('FARADAY_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
    let metadata = new grpc.Metadata();
    metadata.add('macaroon', macaroon);
    callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
const faradayServer = new frdrpc.FaradayServer('localhost:8465', creds);
let request = { 
  rec_request: <CloseRecommendationRequest>, 
  threshold_value: <float>, 
};
faradayServer.thresholdRecommendations(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "total_channels": <int32>,
//      "considered_channels": <int32>,
//      "recommendations": <array Recommendation>,
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/closereport
{ 
    "channel_point": <string>, 
    "channel_initiator": <boolean>, 
    "close_type": <string>, 
    "close_txid": <string>, 
    "open_fee": <string>, 
    "close_fee": <string>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/closereport'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "channel_point": <string>, 
    "channel_initiator": <boolean>, 
    "close_type": <string>, 
    "close_txid": <string>, 
    "open_fee": <string>, 
    "close_fee": <string>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/closereport',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "channel_point": <string>, 
//      "channel_initiator": <boolean>, 
//      "close_type": <string>, 
//      "close_txid": <string>, 
//      "open_fee": <string>, 
//      "close_fee": <string>, 
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/exchangerate
{ 
    "rates": <array frdrpcExchangeRate>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/exchangerate'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "rates": <array frdrpcExchangeRate>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/exchangerate',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "rates": <array frdrpcExchangeRate>, 
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/insights
{ 
    "channel_insights": <array frdrpcChannelInsight>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/insights'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "channel_insights": <array frdrpcChannelInsight>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/insights',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "channel_insights": <array frdrpcChannelInsight>, 
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/nodeaudit
{ 
    "reports": <array frdrpcReportEntry>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/nodeaudit'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "reports": <array frdrpcReportEntry>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/nodeaudit',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "reports": <array frdrpcReportEntry>, 
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/outliers/{rec_request.metric}
{ 
    "total_channels": <int32>, 
    "considered_channels": <int32>, 
    "recommendations": <array frdrpcRecommendation>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/outliers/{rec_request.metric}'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "total_channels": <int32>, 
    "considered_channels": <int32>, 
    "recommendations": <array frdrpcRecommendation>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/outliers/{rec_request.metric}',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "total_channels": <int32>, 
//      "considered_channels": <int32>, 
//      "recommendations": <array frdrpcRecommendation>, 
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/revenue
{ 
    "reports": <array frdrpcRevenueReport>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/revenue'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "reports": <array frdrpcRevenueReport>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/revenue',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "reports": <array frdrpcRevenueReport>, 
//  }

$ MACAROON_HEADER="Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $FARADAY_DIR/regtest/faraday.macaroon)"
$ curl -X GET --cacert $FARADAY_DIR/tls.cert --header "$MACAROON_HEADER" https:://localhost:8082/v1/faraday/threshold/{rec_request.metric}
{ 
    "total_channels": <int32>, 
    "considered_channels": <int32>, 
    "recommendations": <array frdrpcRecommendation>, 
}

>>> import base64, json, requests
>>> url = 'https://localhost:8082/v1/faraday/threshold/{rec_request.metric}'
>>> cert_path = 'FARADAY_DIR/tls.cert'
>>> macaroon = codecs.encode(open('FARADAY_DIR/regtest/faraday.macaroon', 'rb').read(), 'hex')
>>> headers = {'Grpc-Metadata-macaroon': macaroon}
>>> r = requests.get(url, verify=cert_path)
>>> print(r.json())
{ 
    "total_channels": <int32>, 
    "considered_channels": <int32>, 
    "recommendations": <array frdrpcRecommendation>, 
}

const fs = require('fs');
const request = require('request');
const macaroon = fs.readFileSync('FARADAY_DIR/regtest/faraday.macaroon').toString('hex');
let options = {
  url: 'https://localhost:8082/v1/faraday/threshold/{rec_request.metric}',
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': macaroon
  },
};
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  { 
//      "total_channels": <int32>, 
//      "considered_channels": <int32>, 
//      "recommendations": <array frdrpcRecommendation>, 
//  }