7569cca19b
To avoid code changing underneath the static migrations, we copy the lnwire dependency in its current form into the migration directory. Ideally the migrations doesn't depend on any code that might change, this takes us a step closer.
140 lines
3.9 KiB
Go
140 lines
3.9 KiB
Go
package lnwire
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// FundingError represents a set of errors that can be encountered and sent
|
|
// during the funding workflow.
|
|
type FundingError uint8
|
|
|
|
const (
|
|
// ErrMaxPendingChannels is returned by remote peer when the number of
|
|
// active pending channels exceeds their maximum policy limit.
|
|
ErrMaxPendingChannels FundingError = 1
|
|
|
|
// ErrSynchronizingChain is returned by a remote peer that receives a
|
|
// channel update or a funding request while it's still syncing to the
|
|
// latest state of the blockchain.
|
|
ErrSynchronizingChain FundingError = 2
|
|
|
|
// ErrChanTooLarge is returned by a remote peer that receives a
|
|
// FundingOpen request for a channel that is above their current
|
|
// soft-limit.
|
|
ErrChanTooLarge FundingError = 3
|
|
)
|
|
|
|
// String returns a human readable version of the target FundingError.
|
|
func (e FundingError) String() string {
|
|
switch e {
|
|
case ErrMaxPendingChannels:
|
|
return "Number of pending channels exceed maximum"
|
|
case ErrSynchronizingChain:
|
|
return "Synchronizing blockchain"
|
|
case ErrChanTooLarge:
|
|
return "channel too large"
|
|
default:
|
|
return "unknown error"
|
|
}
|
|
}
|
|
|
|
// Error returns the human readable version of the target FundingError.
|
|
//
|
|
// NOTE: Satisfies the Error interface.
|
|
func (e FundingError) Error() string {
|
|
return e.String()
|
|
}
|
|
|
|
// ErrorData is a set of bytes associated with a particular sent error. A
|
|
// receiving node SHOULD only print out data verbatim if the string is composed
|
|
// solely of printable ASCII characters. For reference, the printable character
|
|
// set includes byte values 32 through 127 inclusive.
|
|
type ErrorData []byte
|
|
|
|
// Error represents a generic error bound to an exact channel. The message
|
|
// format is purposefully general in order to allow expression of a wide array
|
|
// of possible errors. Each Error message is directed at a particular open
|
|
// channel referenced by ChannelPoint.
|
|
type Error struct {
|
|
// ChanID references the active channel in which the error occurred
|
|
// within. If the ChanID is all zeros, then this error applies to the
|
|
// entire established connection.
|
|
ChanID ChannelID
|
|
|
|
// Data is the attached error data that describes the exact failure
|
|
// which caused the error message to be sent.
|
|
Data ErrorData
|
|
}
|
|
|
|
// NewError creates a new Error message.
|
|
func NewError() *Error {
|
|
return &Error{}
|
|
}
|
|
|
|
// A compile time check to ensure Error implements the lnwire.Message
|
|
// interface.
|
|
var _ Message = (*Error)(nil)
|
|
|
|
// Error returns the string representation to Error.
|
|
//
|
|
// NOTE: Satisfies the error interface.
|
|
func (c *Error) Error() string {
|
|
errMsg := "non-ascii data"
|
|
if isASCII(c.Data) {
|
|
errMsg = string(c.Data)
|
|
}
|
|
|
|
return fmt.Sprintf("chan_id=%v, err=%v", c.ChanID, errMsg)
|
|
}
|
|
|
|
// Decode deserializes a serialized Error message stored in the passed
|
|
// io.Reader observing the specified protocol version.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (c *Error) Decode(r io.Reader, pver uint32) error {
|
|
return ReadElements(r,
|
|
&c.ChanID,
|
|
&c.Data,
|
|
)
|
|
}
|
|
|
|
// Encode serializes the target Error into the passed io.Writer observing the
|
|
// protocol version specified.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (c *Error) Encode(w io.Writer, pver uint32) error {
|
|
return WriteElements(w,
|
|
c.ChanID,
|
|
c.Data,
|
|
)
|
|
}
|
|
|
|
// MsgType returns the integer uniquely identifying an Error message on the
|
|
// wire.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (c *Error) MsgType() MessageType {
|
|
return MsgError
|
|
}
|
|
|
|
// MaxPayloadLength returns the maximum allowed payload size for an Error
|
|
// complete message observing the specified protocol version.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (c *Error) MaxPayloadLength(uint32) uint32 {
|
|
// 32 + 2 + 65501
|
|
return MaxMessagePayload
|
|
}
|
|
|
|
// isASCII is a helper method that checks whether all bytes in `data` would be
|
|
// printable ASCII characters if interpreted as a string.
|
|
func isASCII(data []byte) bool {
|
|
for _, c := range data {
|
|
if c < 32 || c > 126 {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|