StaticAddressLoopIn

loop:static StaticAddressLoopIn initiates a static address loop-in swap.

Source: looprpc/client.proto

gRPC

rpc StaticAddressLoopIn (StaticAddressLoopInRequest) returns (StaticAddressLoopInResponse);

REST

HTTP Method	Path
POST	/v1/staticaddr/loopin

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 = {
  outpoints: <string>,
  max_swap_fee_satoshis: <int64>,
  last_hop: <bytes>,
  label: <string>,
  initiator: <string>,
  route_hints: <RouteHint>,
  private: <bool>,
  payment_timeout_seconds: <uint32>,
  amount: <int64>,
  fast: <bool>,
};
client.staticAddressLoopIn(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "swap_hash": <bytes>,
//    "state": <string>,
//    "amount": <uint64>,
//    "htlc_cltv": <int32>,
//    "quoted_swap_fee_satoshis": <int64>,
//    "max_swap_fee_satoshis": <int64>,
//    "initiation_height": <uint32>,
//    "protocol_version": <string>,
//    "label": <string>,
//    "initiator": <string>,
//    "payment_timeout_seconds": <uint32>,
//    "used_deposits": <Deposit>,
//    "swap_amount": <uint64>,
//    "change": <int64>,
//    "fast": <bool>,
//  }

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.StaticAddressLoopInRequest(
  outpoints=<string>,
  max_swap_fee_satoshis=<int64>,
  last_hop=<bytes>,
  label=<string>,
  initiator=<string>,
  route_hints=<RouteHint>,
  private=<bool>,
  payment_timeout_seconds=<uint32>,
  amount=<int64>,
  fast=<bool>,
)
response = stub.StaticAddressLoopIn(request)
print(response)
# {
#    "swap_hash": <bytes>,
#    "state": <string>,
#    "amount": <uint64>,
#    "htlc_cltv": <int32>,
#    "quoted_swap_fee_satoshis": <int64>,
#    "max_swap_fee_satoshis": <int64>,
#    "initiation_height": <uint32>,
#    "protocol_version": <string>,
#    "label": <string>,
#    "initiator": <string>,
#    "payment_timeout_seconds": <uint32>,
#    "used_deposits": <Deposit>,
#    "swap_amount": <uint64>,
#    "change": <int64>,
#    "fast": <bool>,
# }

REST

Javascript

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

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

let requestBody = {
  outpoints: <array>, // <string> 
  max_swap_fee_satoshis: <string>, // <int64> 
  last_hop: <string>, // <bytes> (base64 encoded)
  label: <string>, // <string> 
  initiator: <string>, // <string> 
  route_hints: <array>, // <RouteHint> 
  private: <boolean>, // <bool> 
  payment_timeout_seconds: <integer>, // <uint32> 
  amount: <string>, // <int64> 
  fast: <boolean>, // <bool> 
};
let options = {
  url: `https://${REST_HOST}/v1/staticaddr/loopin`,
  // 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:
//  {
//    "swap_hash": <string>, // <bytes> 
//    "state": <string>, // <string> 
//    "amount": <string>, // <uint64> 
//    "htlc_cltv": <integer>, // <int32> 
//    "quoted_swap_fee_satoshis": <string>, // <int64> 
//    "max_swap_fee_satoshis": <string>, // <int64> 
//    "initiation_height": <integer>, // <uint32> 
//    "protocol_version": <string>, // <string> 
//    "label": <string>, // <string> 
//    "initiator": <string>, // <string> 
//    "payment_timeout_seconds": <integer>, // <uint32> 
//    "used_deposits": <array>, // <Deposit> 
//    "swap_amount": <string>, // <uint64> 
//    "change": <string>, // <int64> 
//    "fast": <boolean>, // <bool> 
//  }

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/staticaddr/loopin'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'outpoints': <string>,
  'max_swap_fee_satoshis': <int64>,
  'last_hop': base64.b64encode(<bytes>),
  'label': <string>,
  'initiator': <string>,
  'route_hints': <RouteHint>,
  'private': <bool>,
  'payment_timeout_seconds': <uint32>,
  'amount': <int64>,
  'fast': <bool>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "swap_hash": <bytes>,
#    "state": <string>,
#    "amount": <uint64>,
#    "htlc_cltv": <int32>,
#    "quoted_swap_fee_satoshis": <int64>,
#    "max_swap_fee_satoshis": <int64>,
#    "initiation_height": <uint32>,
#    "protocol_version": <string>,
#    "label": <string>,
#    "initiator": <string>,
#    "payment_timeout_seconds": <uint32>,
#    "used_deposits": <Deposit>,
#    "swap_amount": <uint64>,
#    "change": <int64>,
#    "fast": <bool>,
# }

Shell

# There is no CLI command for this RPC

Messages

looprpc.StaticAddressLoopInRequest

Source: looprpc/client.proto

Field	gRPC Type	REST Type	REST Placement
outpoints The outpoints of the deposits to loop-in.	string[]	array	body
max_swap_fee_satoshis Maximum satoshis we are willing to pay the server for the swap. This value is not disclosed in the swap initiation call, but if the server asks for a higher fee, we abort the swap. Typically this value is taken from the response of the GetQuote call.	int64	string	body
last_hop Optionally the client can specify the last hop pubkey when requesting a loop-in quote. This is useful to get better off-chain routing fee from the server.	bytes	string	body
label An optional label for this swap. This field is limited to 500 characters and may not be one of the reserved values in loop/labels Reserved list.	string	string	body
initiator An optional identification string that will be appended to the user agent string sent to the server to give information about the usage of loop. This initiator part is meant for user interfaces to add their name to give the full picture of the binary used (loopd, LiT) and the method used for triggering the swap (loop CLI, autolooper, LiT UI, other 3rd party UI).	string	string	body
route_hints Optional route hints to reach the destination through private channels.	RouteHint[]	array	body
private Private indicates whether the destination node should be considered private. In which case, loop will generate hop hints to assist with probing and payment.	bool	boolean	body
payment_timeout_seconds The swap payment timeout allows the user to specify an upper limit for the amount of time the server is allowed to take to fulfill the off-chain swap payment. If the timeout is reached the swap will be aborted on the server side and the client can retry the swap with different parameters.	uint32	integer	body
amount The optional swap amount the client is attempting to swap. It can be provided in combination with the outpoints or separately. If provided with outpoints the client takes out this amount from the sum of provided outpoints and sends the change back to the static address. If the amount is provided without outpoints, the client will select deposits automatically. The coin selection strategy is simplified by sorting all available deposits in descending order by amount, and equal amounts in ascending order of blocks until expiry, and then selecting the largest deposits first until the amount is reached. The change will be sent back to the static address. If a subset of outpoints suffice to cover the specified amount the swap will be canceled to allow the user to safe on transaction fees.	int64	string	body
fast If set, request the server to use fast publication behavior.	bool	boolean	body

looprpc.StaticAddressLoopInResponse

Source: looprpc/client.proto

Field	gRPC Type	REST Type
swap_hash The swap hash that identifies this swap.	bytes	string
state The state the swap is in.	string	string
amount The amount of the swap.	uint64	string
htlc_cltv The htlc cltv expiry height of the swap.	int32	integer
quoted_swap_fee_satoshis The quoted swap fee in satoshis.	int64	string
max_swap_fee_satoshis The maximum total swap fee the client is willing to pay for the swap.	int64	string
initiation_height The block height at which the swap was initiated.	uint32	integer
protocol_version The static address protocol version.	string	string
label An optional label for this swap.	string	string
initiator An optional identification string that will be appended to the user agent string sent to the server to give information about the usage of loop. This initiator part is meant for user interfaces to add their name to give the full picture of the binary used (loopd, LiT) and the method used for triggering the swap (loop CLI, autolooper, LiT UI, other 3rd party UI).	string	string
payment_timeout_seconds The swap payment timeout allows the user to specify an upper limit for the amount of time the server is allowed to take to fulfill the off-chain swap payment. If the timeout is reached the swap will be aborted on the server side and the client can retry the swap with different parameters.	uint32	integer
used_deposits The deposits that are used for this swap.	Deposit[]	array
swap_amount The amount that is being swapped (may be less than total deposit value if change is returned).	uint64	string
change The change amount that will be returned to the static address.	int64	string
fast If set, indicates that the server was requested to use fast publication behavior.	bool	boolean

Nested Messages

looprpc.Deposit

Field	gRPC Type	REST Type
id The identifier of the deposit.	bytes	string
state The state of the deposit.	DepositState	string
outpoint The outpoint of the deposit in format txid:index.	string	string
value The value of the deposit in satoshis.	int64	string
confirmation_height The block height at which the deposit was confirmed.	int64	string
blocks_until_expiry The number of blocks that are left until the deposit cannot be used for a loop-in swap anymore.	int64	string
swap_hash The swap hash of the swap that this deposit is part of. This field is only set if the deposit is part of a loop-in swap.	bytes	string

Enums

looprpc.DepositState

Name	Number
UNKNOWN_STATE UNKNOWN_STATE is the default state of a deposit.	0
DEPOSITED DEPOSITED indicates that the deposit has been sufficiently confirmed on chain.	1
WITHDRAWING WITHDRAWING indicates that the deposit is currently being withdrawn. It flips to WITHDRAWN once the withdrawal transaction has been sufficiently confirmed.	2
WITHDRAWN WITHDRAWN indicates that the deposit has been withdrawn.	3
LOOPING_IN LOOPING_IN indicates that the deposit is currently being used in a static address loop-in swap.	4
LOOPED_IN LOOPED_IN indicates that the deposit was used in a static address loop-in swap.	5
SWEEP_HTLC_TIMEOUT SWEEP_HTLC_TIMEOUT indicates that the deposit is part of an active loop-in of which the respective htlc was published by the server and the timeout path has opened up for the client to sweep.	6
HTLC_TIMEOUT_SWEPT HTLC_TIMEOUT_SWEPT indicates that the timeout path of the htlc has been swept by the client.	7
PUBLISH_EXPIRED PUBLISH_EXPIRED indicates that the deposit has expired and the sweep transaction has been published.	8
WAIT_FOR_EXPIRY_SWEEP WAIT_FOR_EXPIRY_SWEEP indicates that the deposit has expired and the sweep transaction has not yet been sufficiently confirmed.	9
EXPIRED EXPIRED indicates that the deposit has expired and the sweep transaction has been sufficiently confirmed.	10