ClosedChannels

ClosedChannels returns a description of all the closed channels that this node was a participant in.

Source: lightning.proto

gRPC

rpc ClosedChannels (ClosedChannelsRequest) returns (ClosedChannelsResponse);

REST

HTTP Method	Path
GET	/v1/channels/closed

Code Samples

gRPC

Javascript

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const GRPC_HOST = 'localhost:10009'
const MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'
const TLS_PATH = 'LND_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('lightning.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const tlsCert = fs.readFileSync(TLS_PATH);
const sslCreds = grpc.credentials.createSsl(tlsCert);
const macaroon = fs.readFileSync(MACAROON_PATH).toString('hex');
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);
let client = new lnrpc.Lightning(GRPC_HOST, creds);
let request = {
  cooperative: <bool>,
  local_force: <bool>,
  remote_force: <bool>,
  breach: <bool>,
  funding_canceled: <bool>,
  abandoned: <bool>,
};
client.closedChannels(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "channels": <ChannelCloseSummary>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the lightning.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import lightning_pb2 as lnrpc, lightning_pb2_grpc as lightningstub

GRPC_HOST = 'localhost:10009'
MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'
TLS_PATH = 'LND_DIR/tls.cert'

# create macaroon credentials
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
def metadata_callback(context, callback):
  callback([('macaroon', macaroon)], None)
auth_creds = grpc.metadata_call_credentials(metadata_callback)
# create SSL credentials
os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
cert = open(TLS_PATH, 'rb').read()
ssl_creds = grpc.ssl_channel_credentials(cert)
# combine macaroon and SSL credentials
combined_creds = grpc.composite_channel_credentials(ssl_creds, auth_creds)
# make the request
channel = grpc.secure_channel(GRPC_HOST, combined_creds)
stub = lightningstub.LightningStub(channel)
request = lnrpc.ClosedChannelsRequest(
  cooperative=<bool>,
  local_force=<bool>,
  remote_force=<bool>,
  breach=<bool>,
  funding_canceled=<bool>,
  abandoned=<bool>,
)
response = stub.ClosedChannels(request)
print(response)
# {
#    "channels": <ChannelCloseSummary>,
# }

REST

Javascript

const fs = require('fs');
const request = require('request');

const REST_HOST = 'localhost:8080'
const MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'

let options = {
  url: `https://${REST_HOST}/v1/channels/closed`,
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
}
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  {
//    "channels": <array>, // <ChannelCloseSummary> 
//  }

Python

import base64, codecs, json, requests

REST_HOST = 'localhost:8080'
MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'
TLS_PATH = 'LND_DIR/tls.cert'

url = f'https://{REST_HOST}/v1/channels/closed'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
r = requests.get(url, headers=headers, verify=TLS_PATH)
print(r.json())
# {
#    "channels": <ChannelCloseSummary>,
# }

Shell

$ lncli closedchannels --help

NAME:
   lncli closedchannels - List all closed channels.

USAGE:
   lncli closedchannels [command options] [arguments...]

CATEGORY:
   Channels

OPTIONS:
   --cooperative       list channels that were closed cooperatively
   --local_force       list channels that were force-closed by the local node
   --remote_force      list channels that were force-closed by the remote node
   --breach            list channels for which the remote node attempted to broadcast a prior revoked channel state
   --funding_canceled  list channels that were never fully opened
   --abandoned         list channels that were abandoned by the local node
   

Messages

lnrpc.ClosedChannelsRequest

Source: lightning.proto

Field	gRPC Type	REST Type	REST Placement
cooperative	bool	boolean	query
local_force	bool	boolean	query
remote_force	bool	boolean	query
breach	bool	boolean	query
funding_canceled	bool	boolean	query
abandoned	bool	boolean	query

lnrpc.ClosedChannelsResponse

Source: lightning.proto

Field	gRPC Type	REST Type
channels	ChannelCloseSummary[]	array

Nested Messages

lnrpc.ChannelCloseSummary

Field	gRPC Type	REST Type
channel_point The outpoint (txid:index) of the funding transaction.	string	string
chan_id The unique channel ID for the channel.	uint64	string
chain_hash The hash of the genesis block that this channel resides within.	string	string
closing_tx_hash The txid of the transaction which ultimately closed this channel.	string	string
remote_pubkey Public key of the remote peer that we formerly had a channel with.	string	string
capacity Total capacity of the channel.	int64	string
close_height Height at which the funding transaction was spent.	uint32	integer
settled_balance Settled balance at the time of channel closure	int64	string
time_locked_balance The sum of all the time-locked outputs at the time of channel closure	int64	string
close_type Details on how the channel was closed.	ClosureType	string
open_initiator Open initiator is the party that initiated opening the channel. Note that this value may be unknown if the channel was closed before we migrated to store open channel information after close.	Initiator	string
close_initiator Close initiator indicates which party initiated the close. This value will be unknown for channels that were cooperatively closed before we started tracking cooperative close initiators. Note that this indicates which party initiated a close, and it is possible for both to initiate cooperative or force closes, although only one party's close will be confirmed on chain.	Initiator	string
resolutions	Resolution[]	array
alias_scids This lists out the set of alias short channel ids that existed for the closed channel. This may be empty.	uint64[]	array
zero_conf_confirmed_scid The confirmed SCID for a zero-conf channel.	uint64	string

lnrpc.Resolution

Field	gRPC Type	REST Type
resolution_type The type of output we are resolving.	ResolutionType	string
outcome The outcome of our on chain action that resolved the outpoint.	ResolutionOutcome	string
outpoint The outpoint that was spent by the resolution.	OutPoint	object
amount_sat The amount that was claimed by the resolution.	uint64	string
sweep_txid The hex-encoded transaction ID of the sweep transaction that spent the output.	string	string

lnrpc.OutPoint

Field	gRPC Type	REST Type
txid_bytes Raw bytes representing the transaction id.	bytes	string
txid_str Reversed, hex-encoded string representing the transaction id.	string	string
output_index The index of the output on the transaction.	uint32	integer

Enums

lnrpc.ChannelCloseSummary.ClosureType

Name	Number
COOPERATIVE_CLOSE	0
LOCAL_FORCE_CLOSE	1
REMOTE_FORCE_CLOSE	2
BREACH_CLOSE	3
FUNDING_CANCELED	4
ABANDONED	5

lnrpc.Initiator

Name	Number
INITIATOR_UNKNOWN	0
INITIATOR_LOCAL	1
INITIATOR_REMOTE	2
INITIATOR_BOTH	3

lnrpc.ResolutionType

Name	Number
TYPE_UNKNOWN	0
ANCHOR We resolved an anchor output.	1
INCOMING_HTLC We are resolving an incoming htlc on chain. This if this htlc is claimed, we swept the incoming htlc with the preimage. If it is timed out, our peer swept the timeout path.	2
OUTGOING_HTLC We are resolving an outgoing htlc on chain. If this htlc is claimed, the remote party swept the htlc with the preimage. If it is timed out, we swept it with the timeout path.	3
COMMIT We force closed and need to sweep our time locked commitment output.	4

lnrpc.ResolutionOutcome

Name	Number
OUTCOME_UNKNOWN Outcome unknown.	0
CLAIMED An output was claimed on chain.	1
UNCLAIMED An output was left unclaimed on chain.	2
ABANDONED ResolverOutcomeAbandoned indicates that an output that we did not claim on chain, for example an anchor that we did not sweep and a third party claimed on chain, or a htlc that we could not decode so left unclaimed.	3
FIRST_STAGE If we force closed our channel, our htlcs need to be claimed in two stages. This outcome represents the broadcast of a timeout or success transaction for this two stage htlc claim.	4
TIMEOUT A htlc was timed out on chain.	5