GetLiquidityParams

GetLiquidityParams gets the parameters that the daemon's liquidity manager is currently configured with. This may be nil if nothing is configured. [EXPERIMENTAL]: endpoint is subject to change.

Source: looprpc/client.proto

gRPC

rpc GetLiquidityParams (GetLiquidityParamsRequest) returns (LiquidityParameters);

REST

HTTP Method	Path
GET	/v1/liquidity/params

Code Samples

gRPC

Javascript

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

const GRPC_HOST = 'localhost:11010'
const MACAROON_PATH = 'LOOP_DIR/regtest/loop.macaroon'
const TLS_PATH = 'LOOP_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('looprpc/client.proto', loaderOptions);
const looprpc = grpc.loadPackageDefinition(packageDefinition).looprpc;
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 looprpc.SwapClient(GRPC_HOST, creds);
let request = {};
client.getLiquidityParams(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "rules": <LiquidityRule>,
//    "fee_ppm": <uint64>,
//    "sweep_fee_rate_sat_per_vbyte": <uint64>,
//    "max_swap_fee_ppm": <uint64>,
//    "max_routing_fee_ppm": <uint64>,
//    "max_prepay_routing_fee_ppm": <uint64>,
//    "max_prepay_sat": <uint64>,
//    "max_miner_fee_sat": <uint64>,
//    "sweep_conf_target": <int32>,
//    "failure_backoff_sec": <uint64>,
//    "autoloop": <bool>,
//    "autoloop_budget_sat": <uint64>,
//    "autoloop_budget_start_sec": <uint64>,
//    "auto_max_in_flight": <uint64>,
//    "min_swap_amount": <uint64>,
//    "max_swap_amount": <uint64>,
//    "htlc_conf_target": <int32>,
//    "autoloop_dest_address": <string>,
//    "autoloop_budget_refresh_period_sec": <uint64>,
//    "autoloop_budget_last_refresh": <uint64>,
//    "easy_autoloop": <bool>,
//    "easy_autoloop_local_target_sat": <uint64>,
//    "account": <string>,
//    "account_addr_type": <AddressType>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the looprpc/client.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import client_pb2 as looprpc, client_pb2_grpc as clientstub

GRPC_HOST = 'localhost:11010'
MACAROON_PATH = 'LOOP_DIR/regtest/loop.macaroon'
TLS_PATH = 'LOOP_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 = clientstub.SwapClientStub(channel)
request = looprpc.GetLiquidityParamsRequest()
response = stub.GetLiquidityParams(request)
print(response)
# {
#    "rules": <LiquidityRule>,
#    "fee_ppm": <uint64>,
#    "sweep_fee_rate_sat_per_vbyte": <uint64>,
#    "max_swap_fee_ppm": <uint64>,
#    "max_routing_fee_ppm": <uint64>,
#    "max_prepay_routing_fee_ppm": <uint64>,
#    "max_prepay_sat": <uint64>,
#    "max_miner_fee_sat": <uint64>,
#    "sweep_conf_target": <int32>,
#    "failure_backoff_sec": <uint64>,
#    "autoloop": <bool>,
#    "autoloop_budget_sat": <uint64>,
#    "autoloop_budget_start_sec": <uint64>,
#    "auto_max_in_flight": <uint64>,
#    "min_swap_amount": <uint64>,
#    "max_swap_amount": <uint64>,
#    "htlc_conf_target": <int32>,
#    "autoloop_dest_address": <string>,
#    "autoloop_budget_refresh_period_sec": <uint64>,
#    "autoloop_budget_last_refresh": <uint64>,
#    "easy_autoloop": <bool>,
#    "easy_autoloop_local_target_sat": <uint64>,
#    "account": <string>,
#    "account_addr_type": <AddressType>,
# }

REST

Javascript

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

const REST_HOST = 'localhost:8081'
const MACAROON_PATH = 'LOOP_DIR/regtest/loop.macaroon'

let options = {
  url: `https://${REST_HOST}/v1/liquidity/params`,
  // 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:
//  {
//    "rules": <array>, // <LiquidityRule> 
//    "fee_ppm": <string>, // <uint64> 
//    "sweep_fee_rate_sat_per_vbyte": <string>, // <uint64> 
//    "max_swap_fee_ppm": <string>, // <uint64> 
//    "max_routing_fee_ppm": <string>, // <uint64> 
//    "max_prepay_routing_fee_ppm": <string>, // <uint64> 
//    "max_prepay_sat": <string>, // <uint64> 
//    "max_miner_fee_sat": <string>, // <uint64> 
//    "sweep_conf_target": <integer>, // <int32> 
//    "failure_backoff_sec": <string>, // <uint64> 
//    "autoloop": <boolean>, // <bool> 
//    "autoloop_budget_sat": <string>, // <uint64> 
//    "autoloop_budget_start_sec": <string>, // <uint64> 
//    "auto_max_in_flight": <string>, // <uint64> 
//    "min_swap_amount": <string>, // <uint64> 
//    "max_swap_amount": <string>, // <uint64> 
//    "htlc_conf_target": <integer>, // <int32> 
//    "autoloop_dest_address": <string>, // <string> 
//    "autoloop_budget_refresh_period_sec": <string>, // <uint64> 
//    "autoloop_budget_last_refresh": <string>, // <uint64> 
//    "easy_autoloop": <boolean>, // <bool> 
//    "easy_autoloop_local_target_sat": <string>, // <uint64> 
//    "account": <string>, // <string> 
//    "account_addr_type": <string>, // <AddressType> 
//  }

Python

import base64, codecs, json, requests

REST_HOST = 'localhost:8081'
MACAROON_PATH = 'LOOP_DIR/regtest/loop.macaroon'
TLS_PATH = 'LOOP_DIR/tls.cert'

url = f'https://{REST_HOST}/v1/liquidity/params'
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())
# {
#    "rules": <LiquidityRule>,
#    "fee_ppm": <uint64>,
#    "sweep_fee_rate_sat_per_vbyte": <uint64>,
#    "max_swap_fee_ppm": <uint64>,
#    "max_routing_fee_ppm": <uint64>,
#    "max_prepay_routing_fee_ppm": <uint64>,
#    "max_prepay_sat": <uint64>,
#    "max_miner_fee_sat": <uint64>,
#    "sweep_conf_target": <int32>,
#    "failure_backoff_sec": <uint64>,
#    "autoloop": <bool>,
#    "autoloop_budget_sat": <uint64>,
#    "autoloop_budget_start_sec": <uint64>,
#    "auto_max_in_flight": <uint64>,
#    "min_swap_amount": <uint64>,
#    "max_swap_amount": <uint64>,
#    "htlc_conf_target": <int32>,
#    "autoloop_dest_address": <string>,
#    "autoloop_budget_refresh_period_sec": <uint64>,
#    "autoloop_budget_last_refresh": <uint64>,
#    "easy_autoloop": <bool>,
#    "easy_autoloop_local_target_sat": <uint64>,
#    "account": <string>,
#    "account_addr_type": <AddressType>,
# }

Shell

$ loop getparams --help

NAME:
   loop getparams - show liquidity manager parameters

USAGE:
   loop getparams [arguments...]

DESCRIPTION:
   Displays the current set of parameters that are set for the liquidity manager.

Messages

looprpc.GetLiquidityParamsRequest

Source: looprpc/client.proto

note

This request has no parameters.

looprpc.LiquidityParameters

Source: looprpc/client.proto

Field	gRPC Type	REST Type
rules A set of liquidity rules that describe the desired liquidity balance.	LiquidityRule[]	array
fee_ppm The parts per million of swap amount that is allowed to be allocated to swap fees. This value is applied across swap categories and may not be set in conjunction with sweep fee rate, swap fee ppm, routing fee ppm, prepay routing, max prepay and max miner fee.	uint64	string
sweep_fee_rate_sat_per_vbyte The limit we place on our estimated sweep cost for a swap in sat/vByte. If the estimated fee for our sweep transaction within the specified confirmation target is above this value, we will not suggest any swaps.	uint64	string
max_swap_fee_ppm The maximum fee paid to the server for facilitating the swap, expressed as parts per million of the swap volume.	uint64	string
max_routing_fee_ppm The maximum fee paid to route the swap invoice off chain, expressed as parts per million of the volume being routed.	uint64	string
max_prepay_routing_fee_ppm The maximum fee paid to route the prepay invoice off chain, expressed as parts per million of the volume being routed.	uint64	string
max_prepay_sat The maximum no-show penalty in satoshis paid for a swap.	uint64	string
max_miner_fee_sat The maximum miner fee we will pay to sweep the swap on chain. Note that we will not suggest a swap if the estimate is above the sweep limit set by these parameters, and we use the current fee estimate to sweep on chain so this value is only a cap placed on the amount we spend on fees in the case where the swap needs to be claimed on chain, but fees have suddenly spiked.	uint64	string
sweep_conf_target The number of blocks from the on-chain HTLC's confirmation height that it should be swept within.	int32	integer
failure_backoff_sec The amount of time we require pass since a channel was part of a failed swap due to off chain payment failure until it will be considered for swap suggestions again, expressed in seconds.	uint64	string
autoloop Set to true to enable automatic dispatch of swaps. All swaps will be limited to the fee categories set by these parameters, and total expenditure will be limited to the autoloop budget.	bool	boolean
autoloop_budget_sat The total budget for automatically dispatched swaps since the budget start time, expressed in satoshis.	uint64	string
autoloop_budget_start_secdeprecated Deprecated, use autoloop_budget_refresh_period_sec. The start time for autoloop budget, expressed as a unix timestamp in seconds. If this value is 0, the budget will be applied for all automatically dispatched swaps. Swaps that were completed before this date will not be included in budget calculations.	uint64	string
auto_max_in_flight The maximum number of automatically dispatched swaps that we allow to be in flight at any point in time.	uint64	string
min_swap_amount The minimum amount, expressed in satoshis, that the autoloop client will dispatch a swap for. This value is subject to the server-side limits specified by the LoopOutTerms endpoint.	uint64	string
max_swap_amount The maximum amount, expressed in satoshis, that the autoloop client will dispatch a swap for. This value is subject to the server-side limits specified by the LoopOutTerms endpoint.	uint64	string
htlc_conf_target The confirmation target for loop in on-chain htlcs.	int32	integer
autoloop_dest_address The destination address to use for autoloop loop outs. Set to "default" in order to revert to default behavior.	string	string
autoloop_budget_refresh_period_sec The period over which the autoloop budget is refreshed, expressed in seconds.	uint64	string
autoloop_budget_last_refresh The time at which the autoloop budget was last refreshed, expressed as a UNIX timestamp in seconds.	uint64	string
easy_autoloop Set to true to enable easy autoloop. If set, all channel/peer rules will be overridden and the client will automatically dispatch swaps in order to meet the configured local balance target size. Currently only loop out is supported, meaning that easy autoloop can only reduce the funds that are held as balance in channels.	bool	boolean
easy_autoloop_local_target_sat The local balance target size, expressed in satoshis. This is used by easy autoloop to determine how much liquidity should be maintained in channels.	uint64	string
account An alternative destination address source for the swap. This field represents the name of the account in the backing lnd instance. Refer to lnd's wallet import functions for reference.	string	string
account_addr_type The address type of the account specified in the account field.	AddressType	string

Nested Messages

looprpc.LiquidityRule

Field	gRPC Type	REST Type
channel_id The short channel ID of the channel that this rule should be applied to. This field may not be set when the pubkey field is set.	uint64	string
swap_type The type of swap that will be dispatched for this rule.	SwapType	string
pubkey The public key of the peer that this rule should be applied to. This field may not be set when the channel id field is set.	bytes	string
type Type indicates the type of rule that this message rule represents. Setting this value will determine which fields are used in the message. The comments on each field in this message will be prefixed with the LiquidityRuleType they belong to.	LiquidityRuleType	string
incoming_threshold THRESHOLD: The percentage of total capacity that incoming capacity should not drop beneath.	uint32	integer
outgoing_threshold THRESHOLD: The percentage of total capacity that outgoing capacity should not drop beneath.	uint32	integer

Enums

looprpc.AddressType

Name	Number
ADDRESS_TYPE_UNKNOWN	0
TAPROOT_PUBKEY	1

looprpc.LiquidityRuleType

Name	Number
UNKNOWN	0
THRESHOLD	1

looprpc.SwapType

Name	Number
LOOP_OUT LOOP_OUT indicates an loop out swap (off-chain to on-chain)	0
LOOP_IN LOOP_IN indicates a loop in swap (on-chain to off-chain)	1