ConnectPeer

ConnectPeer attempts to establish a connection to a remote peer. This is at the networking level, and is used for communication between nodes. This is distinct from establishing a channel with a peer.

Source: lightning.proto

gRPC

rpc ConnectPeer (ConnectPeerRequest) returns (ConnectPeerResponse);

REST

HTTP Method	Path
POST	/v1/peers

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 = {
  addr: <LightningAddress>,
  perm: <bool>,
  timeout: <uint64>,
};
client.connectPeer(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "status": <string>,
//  }

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.ConnectPeerRequest(
  addr=<LightningAddress>,
  perm=<bool>,
  timeout=<uint64>,
)
response = stub.ConnectPeer(request)
print(response)
# {
#    "status": <string>,
# }

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 requestBody = {
  addr: <object>, // <LightningAddress> 
  perm: <boolean>, // <bool> 
  timeout: <string>, // <uint64> 
};
let options = {
  url: `https://${REST_HOST}/v1/peers`,
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
  form: JSON.stringify(requestBody),
}
request.post(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  {
//    "status": <string>, // <string> 
//  }

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/peers'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'addr': <LightningAddress>,
  'perm': <bool>,
  'timeout': <uint64>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "status": <string>,
# }

Shell

$ lncli connect --help

NAME:
   lncli connect - Connect to a remote lightning peer.

USAGE:
   lncli connect [command options] <pubkey>@host

CATEGORY:
   Peers

DESCRIPTION:
   
  Connect to a peer using its <pubkey> and host.

  A custom timeout on the connection is supported. For instance, to timeout
  the connection request in 30 seconds, use the following:

  lncli connect <pubkey>@host --timeout 30s
  

OPTIONS:
   --perm  If set, the daemon will attempt to persistently connect to the target peer.
           If not, the call will be synchronous.
   --timeout value  The connection timeout value for current request. Valid uints are {ms, s, m, h}.
If not set, the global connection timeout value (default to 120s) is used. (default: 0s)
   

Messages

lnrpc.ConnectPeerRequest

Source: lightning.proto

Field	gRPC Type	REST Type	REST Placement
addr Lightning address of the peer to connect to.	LightningAddress	object	body
perm If set, the daemon will attempt to persistently connect to the target peer. Otherwise, the call will be synchronous.	bool	boolean	body
timeout The connection timeout value (in seconds) for this request. It won't affect other requests.	uint64	string	body

lnrpc.ConnectPeerResponse

Source: lightning.proto

Field	gRPC Type	REST Type
status The status of the connect operation.	string	string

Nested Messages

lnrpc.LightningAddress

Field	gRPC Type	REST Type
pubkey The identity pubkey of the Lightning node.	string	string
host The network location of the lightning node, e.g. `69.69.69.69:1337` or `localhost:10011`.	string	string