loop

package module
v0.11.2-beta Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 8, 2020 License: MIT Imports: 39 Imported by: 1

README

Lightning Loop

Lightning Loop is a non-custodial service offered by Lightning Labs to bridge on-chain and off-chain Bitcoin using submarine swaps. This repository is home to the Loop client and depends on the Lightning Network daemon lnd. All of lnd’s supported chain backends are fully supported when using the Loop client: Neutrino, Bitcoin Core, and btcd.

In the current iteration of the Loop software, two swap types are supported:

  • off-chain to on-chain, where the Loop client sends funds off-chain in
  • on-chain to off-chain, where the Loop client sends funds to an on-chain address using an off-chain channel

We call off-chain to on-chain swaps, a Loop Out. The service can be used in various situations:

  • Acquiring inbound channel liquidity from arbitrary nodes on the Lightning network
  • Depositing funds to a Bitcoin on-chain address without closing active channels
  • Paying to on-chain fallback addresses in the case of insufficient route liquidity

We call our on-chain to off-chain swaps, a Loop In. This allows you to use on-chain funds to increase the local balance of a channel, effectively "refilling" an existing channel.

Potential uses for Loop In:

  • Refilling depleted channels with funds from cold-wallets or exchange withdrawals
  • Servicing off-chain Lightning withdrawals using on-chain payments, with no funds in channels required
  • As a failsafe payment method that can be used when channel liquidity along a route is insufficient

Development and Support

The Loop client is currently in an early beta state, and offers a simple command line application. Future APIs will be added to support implementation or use of the Loop service.

The Loop daemon exposes a gRPC API (defaults to port 11010) and a REST API (defaults to port 8081).

The GitHub issue tracker can be used to request specific improvements or register and get help with any problems. Community support is also available in the LND Slack .

Setup and Install

LND and the loop client are using Go modules. Make sure that the GO111MODULE env variable is set to on.

In order to execute a swap, you need to run a compatible lnd version built with the correct sub-servers enabled.

LND

To run loop, you need a compatible version of lnd running. It is generally recommended to always keep both lnd and loop updated to the most recent released version.

If you are building from source make sure you are using the latest tagged version of lnd. You can get this by git cloning the repository and checking out a specific tag:

git clone https://github.com/lightningnetwork/lnd.git
cd lnd
git checkout v0.x.x-beta

Once the lnd repository is cloned, it will need to be built with special build tags that enable the swap. This enables the required lnd rpc services.

make install tags="signrpc walletrpc chainrpc invoicesrpc"

Check to see if you have already installed lnd. If you have, you will need to delete the .macaroon files from your lnd directory and restart lnd.

Do not delete any other files other than the .macaroon files

// Example on Linux to see macaroons in the default directory:
ls ~/.lnd/data/chain/bitcoin/mainnet

This should show no .macaroon files. If it does? Stop lnd, delete macaroons, restart lnd.

lncli stop

Now delete the .macaroon files and restart lnd. (don't delete any other files)

Loopd

After lnd is installed, you will need to clone the Lightning Loop repo and install the command line interface and swap client service.

git clone https://github.com/lightninglabs/loop.git
cd loop/cmd
go install ./...

Execute a Swap

After you have lnd and the Loop client installed, you can execute a Loop swap.

The Loop client needs its own short-lived daemon which will deal with the swaps in progress.

Command to start loopd::

loopd

// Or if you want to do everything in the same terminal and background loopd
loopd &

// For testnet mode, you'll need to specify the network as mainnet is the
default:
loopd --network=testnet

By default loopd attempts to connect to the lnd instance running on localhost:10009 and reads the macaroon and tls certificate from ~/.lnd. This can be altered using command line flags. See loopd --help.

loopd only listens on localhost and uses an unencrypted and unauthenticated connection.

Loop Out Swaps

Now that loopd is running, you can initiate a simple Loop Out. This will pay out Lightning off-chain funds and you will receive Bitcoin on-chain funds in return. There will be some chain and routing fees associated with this swap.

NAME:
   loop out - perform an off-chain to on-chain swap (looping out)

USAGE:
   loop out [command options] amt [addr]

DESCRIPTION:

  Attempts to loop out the target amount into either the backing lnd's
  wallet, or a targeted address.

  The amount is to be specified in satoshis.

  Optionally a BASE58/bech32 encoded bitcoin destination address may be
  specified. If not specified, a new wallet address will be generated.

OPTIONS:
   --channel value               the 8-byte compact channel ID of the channel to loop out (default: 0)
   --addr value                  the optional address that the looped out funds should be sent to, if let blank the funds will go to lnd's wallet
   --amt value                   the amount in satoshis to loop out (default: 0)
   --conf_target value           the number of blocks from the swap initiation height that the on-chain HTLC should be swept within (default: 6)
   --max_swap_routing_fee value  the max off-chain swap routing fee in satoshis, if not specified, a default max fee will be used (default: 0)
   --fast                        Indicate you want to swap immediately, paying potentially a higher fee. If not set the swap server might choose to wait up to 30 minutes before publishing the swap HTLC on-chain, to save on its chain fees. Not setting this flag therefore might result in a lower swap fee.

It's possible to receive more inbound capacity on a particular channel (--channel), and also have the loop daemon send the coins to a target address (addr). The latter option allows ones to effectively send on-chain from their existing channels!

loop out <amt_in_satoshis>

This will take some time, as it requires an on-chain confirmation. When the swap is initiated successfully, loopd will see the process through.

To query in-flight swap statuses, run loop monitor.

The loop client also has the ability to automatically dispatch loop out swaps on your behalf - see our autoloop documentation for details.

Fees explained

The following is an example output of a 0.01 BTC fast (non-batched) Loop Out swap from testnet:

$ loop out --amt 1000000 --fast
Max swap fees for 1000000 sat Loop Out: 36046 sat
Fast swap requested.
CONTINUE SWAP? (y/n), expand fee detail (x): x

Estimated on-chain sweep fee:        149 sat
Max on-chain sweep fee:              14900 sat
Max off-chain swap routing fee:      20010 sat
Max off-chain prepay routing fee:    36 sat
Max no show penalty (prepay):        1337 sat
Max swap fee:                        1100 sat
CONTINUE SWAP? (y/n):

Explanation:

  • Max swap fees for sat Loop Out (36046 sat): The absolute maximum in fees that need to be paid. This includes on-chain and off-chain fees. This represents the ceiling or worst-case scenario. The actual fees will likely be lower. This is the sum of 14900 + 20010 + 36 + 1100 (see below).
  • Estimated on-chain sweep fee (149 sat): The estimated cost to sweep the HTLC in case of success, calculated based on the current on-chain fees. This value is called miner_fee in the gRPC/REST responses.
  • Max on-chain sweep fee (14900 sat): The maximum on-chain fee the daemon is going to allow for sweeping the HTLC in case of success. A fee estimation based on the --conf_target flag is always performed before sweeping. The factor of 100 times the estimated fee is applied in case the fees spike between the time the swap is initiated and the time the HTLC can be swept. But that is the absolute worst-case fee that will be paid. If there is no fee spike, a normal, much lower fee will be used.
  • Max off-chain swap routing fee (20010 sat): The maximum off-chain routing fee that the daemon should pay when finding a route to pay the Lightning invoice. This is a hard limit. If no route with a lower or equal fee is found, the payment (and the swap) is aborted. This value is calculated statically based on the swap amount (see maxRoutingFeeBase and maxRoutingFeeRate in cmd/loop/main.go).
  • Max off-chain prepay routing fee (36 sat): The maximum off-chain routing fee that the daemon should pay when finding a route to pay the prepay fee. This is a hard limit. If no route with a lower or equal fee is found, the payment (and the swap) is aborted. This value is calculated statically based on the prepay amount (see maxRoutingFeeBase and maxRoutingFeeRate in cmd/loop/main.go).
  • Max no show penalty (prepay) (1337 sat): This is the amount that has to be pre-paid (off-chain) before the server publishes the HTLC on-chain. This is necessary to ensure the server's on-chain fees are paid if the client aborts and never completes the swap after the HTLC has been published on-chain. If the swap completes normally, this amount is counted towards the full swap amount and therefore is actually a pre-payment and not a fee. This value is called prepay_amt in the gRPC/REST responses.
  • Max swap fee (1100 sat): The maximum amount of service fees we allow the server to charge for executing the swap. The client aborts the swap if the fee proposed by the server exceeds this maximum. It is therefore recommended to obtain the maximum by asking the server for a quote first. The actual fees might be lower than this maximum if user specific discounts are applied. This value is called swap_fee in the gRPC/REST responses.
Fast vs. batched swaps

By default, Loop Outs are executed as normal speed swaps. This means the server will wait up to 30 minutes until it publishes the HTLC on-chain to improve the chances that it can be batched together with other user's swaps to reduce the on-chain footprint and fees. The server offers a reduced swap fee for slow swaps to incentivize users to batch more.

If a swap should be executed immediately, the --fast flag can be used. Fast swaps won't benefit from a reduced swap fee.

Loop In Swaps

Additionally, Loop In is now also supported for mainnet as well. A Loop In swap lets one refill their channel (ability to send more coins) by sending to a special script on-chain.

NAME:
   loop in - perform an on-chain to off-chain swap (loop in)

USAGE:
   loop in [command options] amt

DESCRIPTION:

    Send the amount in satoshis specified by the amt argument off-chain.

OPTIONS:
   --amt value          the amount in satoshis to loop in (default: 0)
   --external           expect htlc to be published externally
   --conf_target value  the target number of blocks the on-chain htlc broadcast by the swap client should confirm within (default: 0)
   --last_hop value     the pubkey of the last hop to use for this swap

The --external argument allows the on-chain HTLC transacting to be published externally. This allows for a number of use cases like using this address to withdraw from an exchange into your Lightning channel!

A Loop In swap can be executed a follows:

loop in <amt_in_satoshis>
Fees explained

The following is an example output of a 0.01 BTC Loop In swap from testnet:

$ loop in --amt 1000000
Max swap fees for 1000000 sat Loop In: 1562 sat
CONTINUE SWAP? (y/n), expand fee detail (x): x

Estimated on-chain HTLC fee:         154 sat
Max swap fee:                        1100 sat
CONTINUE SWAP? (y/n):

Explanation:

  • Estimated on-chain HTLC fee (154 sat): The estimated on-chain fee that the daemon has to pay to publish the HTLC. This is an estimation from lnd's wallet based on the available UTXOs and current network fees. This value is called miner_fee in the gRPC/REST responses.
  • Max swap fee (1100 sat): The maximum amount of service fees we allow the server to charge for executing the swap. The client aborts the swap if the fee proposed by the server exceeds this maximum. It is therefore recommended to obtain the maximum by asking the server for a quote first. The actual fees might be lower than this maximum if user specific discounts are applied. This value is called swap_fee in the gRPC/REST responses.

Resume

When loopd is terminated (or killed) for whatever reason, it will pickup pending swaps after a restart.

Information about pending swaps is stored persistently in the swap database. Its location is ~/.loopd/<network>/loop.db.

Authentication and transport security

The gRPC and REST connections of loopd are encrypted with TLS and secured with macaroon authentication the same way lnd is.

If no custom loop directory is set then the TLS certificate is stored in ~/.loop/<network>/tls.cert and the base macaroon in ~/.loop/<network>/loop.macaroon.

The loop command will pick up these file automatically on mainnet if no custom loop directory is used. For other networks it should be sufficient to add the --network flag to tell the CLI in what sub directory to look for the files.

For more information on macaroons, see the macaroon documentation of lnd.

NOTE: Loop's macaroons are independent from lnd's. The same macaroon cannot be used for both loopd and lnd.

Multiple Simultaneous Swaps

It is possible to execute multiple swaps simultaneously. Just keep loopd running.

API Support Level

Server

The Loop server API and on-chain scripts are kept backwards compatible as long as reasonably possible.

Client

When breaking changes to the Loop client daemon API are made, old fields will be marked as deprecated. Deprecated fields will remain supported until the next minor release.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrSwapFeeTooHigh is returned when the swap invoice amount is too
	// high.
	ErrSwapFeeTooHigh = errors.New("swap fee too high")

	// ErrPrepayAmountTooHigh is returned when the prepay invoice amount is
	// too high.
	ErrPrepayAmountTooHigh = errors.New("prepay amount too high")

	// ErrSwapAmountTooLow is returned when the requested swap amount is
	// less than the server minimum.
	ErrSwapAmountTooLow = errors.New("swap amount too low")

	// ErrSwapAmountTooHigh is returned when the requested swap amount is
	// more than the server maximum.
	ErrSwapAmountTooHigh = errors.New("swap amount too high")

	// ErrExpiryTooFar is returned when the server proposes an expiry that
	// is too soon for us.
	ErrExpiryTooFar = errors.New("swap expiry too far")

	// MinerFeeEstimationFailed is a magic number that is returned in a
	// quote call as the miner fee if the fee estimation in lnd's wallet
	// failed because of insufficient funds.
	MinerFeeEstimationFailed btcutil.Amount = -1
)
View Source 
var (
	// MaxLoopInAcceptDelta configures the maximum acceptable number of
	// remaining blocks until the on-chain htlc expires. This value is used
	// to decide whether we want to continue with the swap parameters as
	// proposed by the server. It is a protection to prevent the server from
	// getting us to lock up our funds to an arbitrary point in the future.
	MaxLoopInAcceptDelta = int32(1500)

	// MinLoopInPublishDelta defines the minimum number of remaining blocks
	// until on-chain htlc expiry required to proceed to publishing the htlc
	// tx. This value isn't critical, as we could even safely publish the
	// htlc after expiry. The reason we do implement this check is to
	// prevent us from publishing an htlc that the server surely wouldn't
	// follow up to.
	MinLoopInPublishDelta = int32(10)

	// TimeoutTxConfTarget defines the confirmation target for the loop in
	// timeout tx.
	TimeoutTxConfTarget = int32(2)
)
View Source 
var (
	// MinLoopOutPreimageRevealDelta configures the minimum number of
	// remaining blocks before htlc expiry required to reveal preimage.
	MinLoopOutPreimageRevealDelta int32 = 20

	// DefaultSweepConfTarget is the default confirmation target we'll use
	// when sweeping on-chain HTLCs.
	DefaultSweepConfTarget int32 = 9

	// DefaultHtlcConfTarget is the default confirmation target we'll use
	// for on-chain htlcs published by the swap client for Loop In.
	DefaultHtlcConfTarget int32 = 6

	// DefaultSweepConfTargetDelta is the delta of blocks from a Loop Out
	// swap's expiration height at which we begin to use the default sweep
	// confirmation target.
	//
	// TODO(wilmer): tune?
	DefaultSweepConfTargetDelta = DefaultSweepConfTarget * 2
)
View Source 
var AgentName = defaultAgentName

AgentName stores the name of the software that is added as the first part of the user agent string. This defaults to the value "loopd" when being run as a standalone component but can be overwritten by LiT for example when loopd is integrated into the UI.

View Source 
var Commit string

Commit stores the current commit hash of this build, this should be set using the -ldflags during compilation.

Functions

func GetHtlcScriptVersion 

func GetHtlcScriptVersion(
	protocolVersion loopdb.ProtocolVersion) swap.ScriptVersion

GetHtlcScriptVersion returns the correct HTLC script version for the passed protocol version.

func UseLogger 

func UseLogger(logger btclog.Logger)

UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using btclog.

func UserAgent 

func UserAgent(initiator string) string

UserAgent returns the full user agent string that identifies the software that is submitting swaps to the loop server.

func Version 

func Version() string

Version returns the application version as a properly formed string per the semantic versioning 2.0.0 spec (http://semver.org/) and the commit it was built on.

Types

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client performs the client side part of swaps. This interface exists to be able to implement a stub.

func NewClient 

func NewClient(dbDir string, cfg *ClientConfig) (*Client, func(), error)

NewClient returns a new instance to initiate swaps with.

func (*Client) FetchSwaps 

func (s *Client) FetchSwaps() ([]*SwapInfo, error)

FetchSwaps returns all loop in and out swaps currently in the database.

func (*Client) LoopIn 

func (s *Client) LoopIn(globalCtx context.Context,
	request *LoopInRequest) (*LoopInSwapInfo, error)

LoopIn initiates a loop in swap.

func (*Client) LoopInQuote 

func (s *Client) LoopInQuote(ctx context.Context,
	request *LoopInQuoteRequest) (*LoopInQuote, error)

LoopInQuote takes an amount and returns a break down of estimated costs for the client. Both the swap server and the on-chain fee estimator are queried to get to build the quote response.

func (*Client) LoopInTerms 

func (s *Client) LoopInTerms(ctx context.Context) (
	*LoopInTerms, error)

LoopInTerms returns the terms on which the server executes swaps.

func (*Client) LoopOut 

func (s *Client) LoopOut(globalCtx context.Context,
	request *OutRequest) (*LoopOutSwapInfo, error)

LoopOut initiates a loop out swap. It blocks until the swap is initiation with the swap server is completed (typically this takes only a short amount of time). From there on further status information can be acquired through the status channel returned from the Run call.

When the call returns, the swap has been persisted and will be resumed automatically after restarts.

The return value is a hash that uniquely identifies the new swap.

func (*Client) LoopOutQuote 

func (s *Client) LoopOutQuote(ctx context.Context,
	request *LoopOutQuoteRequest) (*LoopOutQuote, error)

LoopOutQuote takes a LoopOut amount and returns a break down of estimated costs for the client. Both the swap server and the on-chain fee estimator are queried to get to build the quote response.

func (*Client) LoopOutTerms 

func (s *Client) LoopOutTerms(ctx context.Context) (
	*LoopOutTerms, error)

LoopOutTerms returns the terms on which the server executes swaps.

func (*Client) Run 

func (s *Client) Run(ctx context.Context,
	statusChan chan<- SwapInfo) error

Run is a blocking call that executes all swaps. Any pending swaps are restored from persistent storage and resumed. Subsequent updates will be sent through the passed in statusChan. The function can be terminated by cancelling the context.

type ClientConfig 

type ClientConfig struct {
	// ServerAddress is the loop server to connect to.
	ServerAddress string

	// ProxyAddress is the SOCKS proxy that should be used to establish the
	// connection.
	ProxyAddress string

	// SwapServerNoTLS skips TLS for the swap server connection when set.
	SwapServerNoTLS bool

	// TLSPathServer is the path to the TLS certificate that is required to
	// connect to the server.
	TLSPathServer string

	// Lnd is an instance of the lnd proxy.
	Lnd *lndclient.LndServices

	// MaxLsatCost is the maximum price we are willing to pay to the server
	// for the token.
	MaxLsatCost btcutil.Amount

	// MaxLsatFee is the maximum that we are willing to pay in routing fees
	// to obtain the token.
	MaxLsatFee btcutil.Amount

	// LoopOutMaxParts defines the maximum number of parts that may be used
	// for a loop out swap. When greater than one, a multi-part payment may
	// be attempted.
	LoopOutMaxParts uint32
}

ClientConfig is the exported configuration structure that is required to instantiate the loop client.

type In 

type In struct {
	loopdb.LoopInContract

	SwapInfoKit

	// State where the swap is in.
	State loopdb.SwapState
}

In contains status information for a loop in swap.

func (*In) LastUpdate 

func (s *In) LastUpdate() time.Time

LastUpdate returns the last update time of the swap

func (*In) SwapHash 

func (s *In) SwapHash() lntypes.Hash

SwapHash returns the swap hash.

type LoopInQuote 

type LoopInQuote struct {
	// SwapFee is the fee that the swap server is charging for the swap.
	SwapFee btcutil.Amount

	// MinerFee is an estimate of the on-chain fee that needs to be paid to
	// sweep the htlc.
	MinerFee btcutil.Amount

	// Time lock delta relative to current block height that swap server
	// will accept on the swap initiation call.
	CltvDelta int32
}

LoopInQuote contains estimates for the fees making up the total swap cost for the client.

type LoopInQuoteRequest 

type LoopInQuoteRequest struct {
	// Amount specifies the requested swap amount in sat. This does not
	// include the swap and miner fee.
	Amount btcutil.Amount

	// HtlcConfTarget specifies the targeted confirmation target for the
	// client sweep tx.
	HtlcConfTarget int32

	// ExternalHtlc specifies whether the htlc is published by an external
	// source.
	ExternalHtlc bool
}

LoopInQuoteRequest specifies the swap parameters for which a quote is requested.

type LoopInRequest 

type LoopInRequest struct {
	// Amount specifies the requested swap amount in sat. This does not
	// include the swap and miner fee.
	Amount btcutil.Amount

	// MaxSwapFee is the maximum 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 LoopInQuote call. It
	// includes the prepay amount.
	MaxSwapFee btcutil.Amount

	// MaxMinerFee is the maximum in on-chain fees that we are willing to
	// spent. If we publish the on-chain htlc and the fee estimate turns out
	// higher than this value, we cancel the swap.
	//
	// MaxMinerFee is typically taken from the response of the LoopInQuote
	// call.
	MaxMinerFee btcutil.Amount

	// HtlcConfTarget specifies the targeted confirmation target for the
	// client htlc tx.
	HtlcConfTarget int32

	// LastHop optionally specifies the last hop to use for the loop in
	// payment.
	LastHop *route.Vertex

	// ExternalHtlc specifies whether the htlc is published by an external
	// source.
	ExternalHtlc bool

	// Label contains an optional label for the swap.
	Label string

	// Initiator is an optional string that identifies what software
	// initiated the swap (loop CLI, autolooper, LiT UI and so on) and is
	// appended to the user agent string.
	Initiator string
}

LoopInRequest contains the required parameters for the swap.

type LoopInSwapInfo 

type LoopInSwapInfo struct {
	// SwapHash contains the sha256 hash of the swap preimage.
	SwapHash lntypes.Hash

	// HtlcAddressP2WSH contains the native segwit swap htlc address,
	// where the loop-in funds may be paid.
	HtlcAddressP2WSH btcutil.Address

	// HtlcAddressNP2WSH contains the nested segwit swap htlc address,
	// where the loop-in funds may be paid.
	HtlcAddressNP2WSH btcutil.Address

	// ServerMessages is the human-readable message received from the loop
	// server.
	ServerMessage string
}

LoopInSwapInfo contains essential information of a loop-in swap after the swap is initiated.

type LoopInTerms 

type LoopInTerms struct {
	// MinSwapAmount is the minimum amount that the server requires for a
	// swap.
	MinSwapAmount btcutil.Amount

	// MaxSwapAmount is the maximum amount that the server accepts for a
	// swap.
	MaxSwapAmount btcutil.Amount
}

LoopInTerms are the server terms on which it executes loop in swaps.

type LoopOutQuote 

type LoopOutQuote struct {
	// SwapFee is the fee that the swap server is charging for the swap.
	SwapFee btcutil.Amount

	// PrepayAmount is the part of the swap fee that is requested as a
	// prepayment.
	PrepayAmount btcutil.Amount

	// MinerFee is an estimate of the on-chain fee that needs to be paid to
	// sweep the htlc.
	MinerFee btcutil.Amount

	// SwapPaymentDest is the node pubkey where to swap payment needs to be
	// sent to.
	SwapPaymentDest [33]byte
}

LoopOutQuote contains estimates for the fees making up the total swap cost for the client.

type LoopOutQuoteRequest 

type LoopOutQuoteRequest struct {
	// Amount specifies the requested swap amount in sat. This does not
	// include the swap and miner fee.
	Amount btcutil.Amount

	// SweepConfTarget specifies the targeted confirmation target for the
	// client sweep tx.
	SweepConfTarget int32

	// SwapPublicationDeadline can be set by the client to allow the server
	// delaying publication of the swap HTLC to save on chain fees.
	SwapPublicationDeadline time.Time
}

LoopOutQuoteRequest specifies the swap parameters for which a quote is requested.

type LoopOutSwapInfo 

type LoopOutSwapInfo struct {
	// SwapHash contains the sha256 hash of the swap preimage.
	SwapHash lntypes.Hash

	// HtlcAddressP2WSH contains the native segwit swap htlc address that
	// the server will publish to.
	HtlcAddressP2WSH btcutil.Address

	// ServerMessages is the human-readable message received from the loop
	// server.
	ServerMessage string
}

LoopOutSwapInfo contains essential information of a loop-out swap after the swap is initiated.

type LoopOutTerms 

type LoopOutTerms struct {
	// MinSwapAmount is the minimum amount that the server requires for a
	// swap.
	MinSwapAmount btcutil.Amount

	// MaxSwapAmount is the maximum amount that the server accepts for a
	// swap.
	MaxSwapAmount btcutil.Amount

	// MinCltvDelta is the minimum expiry delta for loop out swaps.
	MinCltvDelta int32

	// MaxCltvDelta is the maximum expiry delta for loop out swaps.
	MaxCltvDelta int32
}

LoopOutTerms are the server terms on which it executes swaps.

type Out 

type Out struct {
	// LoopOutContract describes the details of this loop.Out. Using these
	// details,the full swap can be executed.
	loopdb.LoopOutContract

	// State is the current state of the target swap.
	State loopdb.SwapState

	// SwapInfoKit contains shared data amongst all swap types.
	SwapInfoKit
}

Out contains the full details of a loop out request. This includes things like the payment hash, the total value, and the final CTLV delay of the swap. We'll use this to track an active swap throughout that various swap stages.

type OutRequest 

type OutRequest struct {
	// Amount specifies the requested swap amount in sat. This does not
	// include the swap and miner fee.
	Amount btcutil.Amount

	// Destination address for the swap.
	DestAddr btcutil.Address

	// MaxSwapRoutingFee is the maximum off-chain fee in msat that may be
	// paid for payment to the server. This limit is applied during path
	// finding. Typically this value is taken from the response of the
	// LoopOutQuote call.
	MaxSwapRoutingFee btcutil.Amount

	// MaxPrepayRoutingFee is the maximum off-chain fee in msat that may be
	// paid for payment to the server. This limit is applied during path
	// finding. Typically this value is taken from the response of the
	// LoopOutQuote call.
	MaxPrepayRoutingFee btcutil.Amount

	// MaxSwapFee is the maximum 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 LoopOutQuote call. It
	// includes the prepay amount.
	MaxSwapFee btcutil.Amount

	// MaxPrepayAmount is the maximum amount of the swap fee that may be
	// charged as a prepayment.
	MaxPrepayAmount btcutil.Amount

	// MaxMinerFee is the maximum in on-chain fees that we are willing to
	// spent. If we want to sweep the on-chain htlc and the fee estimate
	// turns out higher than this value, we cancel the swap. If the fee
	// estimate is lower, we publish the sweep tx.
	//
	// If the sweep tx isn't confirmed, we are forced to ratchet up fees
	// until it is swept. Possibly even exceeding MaxMinerFee if we get
	// close to the htlc timeout. Because the initial publication revealed
	// the preimage, we have no other choice. The server may already have
	// pulled the off-chain htlc. Only when the fee becomes higher than the
	// swap amount, we can only wait for fees to come down and hope - if we
	// are past the timeout - that the server isn't publishing the
	// revocation.
	//
	// MaxMinerFee is typically taken from the response of the
	// LoopOutQuote call.
	MaxMinerFee btcutil.Amount

	// SweepConfTarget specifies the targeted confirmation target for the
	// client sweep tx.
	SweepConfTarget int32

	// HtlcConfirmations specifies the number of confirmations we require
	// for on chain loop out htlcs.
	HtlcConfirmations int32

	// OutgoingChanSet optionally specifies the short channel ids of the
	// channels that may be used to loop out.
	OutgoingChanSet loopdb.ChannelSet

	// SwapPublicationDeadline can be set by the client to allow the server
	// delaying publication of the swap HTLC to save on chain fees.
	SwapPublicationDeadline time.Time

	// Expiry is the absolute expiry height of the on-chain htlc.
	Expiry int32

	// Label contains an optional label for the swap.
	Label string

	// Initiator is an optional string that identifies what software
	// initiated the swap (loop CLI, autolooper, LiT UI and so on) and is
	// appended to the user agent string.
	Initiator string
}

OutRequest contains the required parameters for a loop out swap.

type ServerUpdate 

type ServerUpdate struct {
	// State is the state that the server has sent us.
	State looprpc.ServerSwapState

	// Timestamp is the time of the server state update.
	Timestamp time.Time
}

ServerUpdate summarizes an update from the swap server.

type SwapInfo 

type SwapInfo struct {
	loopdb.SwapStateData

	loopdb.SwapContract

	// LastUpdateTime is the time of the last state change.
	LastUpdate time.Time

	// SwapHash stores the swap preimage hash.
	SwapHash lntypes.Hash

	// SwapType describes whether this is a loop in or loop out swap.
	SwapType swap.Type

	// HtlcAddressP2WSH stores the address of the P2WSH (native segwit)
	// swap htlc. This is used for both loop-in and loop-out.
	HtlcAddressP2WSH btcutil.Address

	// HtlcAddressNP2WSH stores the address of the NP2WSH (nested segwit)
	// swap htlc. This is only used for external loop-in.
	HtlcAddressNP2WSH btcutil.Address

	// ExternalHtlc is set to true for external loop-in swaps.
	ExternalHtlc bool
}

SwapInfo exposes common info fields for loop in and loop out swaps.

type SwapInfoKit 

type SwapInfoKit struct {
	// Hash is the sha256 hash of the preimage that unlocks the htlcs. It
	// is used to uniquely identify this swap.
	Hash lntypes.Hash

	// LastUpdateTime is the time of the last update of this swap.
	LastUpdateTime time.Time
}

SwapInfoKit contains common swap info fields.

Source Files

View all Source files

Directories

Path Synopsis
cmd
loop
loopd
Package liquidity is responsible for monitoring our node's liquidity.
 Package liquidity is responsible for monitoring our node's liquidity.
Package looprpc is a reverse proxy.
 Package looprpc is a reverse proxy.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.