channeldb

package

Go to main page

Versions in this module

v0

v0.7.2

Jun 4, 2024

v0.7.1

May 27, 2024

v0.7.0

May 16, 2024

v0.6.0

Feb 22, 2024

Changes in this version

+ const DefaultPreAllocCacheNumNodes

+ type AMPInvoiceState map[SetID]InvoiceStateAMP

+ type CachedEdgePolicy struct

+ ChannelFlags lnwire.ChanUpdateChanFlags

+ ChannelID uint64

+ FeeBaseMAtoms lnwire.MilliAtom

+ FeeProportionalMillionths lnwire.MilliAtom

+ MaxHTLC lnwire.MilliAtom

+ MessageFlags lnwire.ChanUpdateMsgFlags

+ MinHTLC lnwire.MilliAtom

+ TimeLockDelta uint16

+ ToNodeFeatures *lnwire.FeatureVector

+ ToNodePubKey func() route.Vertex

+ func NewCachedPolicy(policy *ChannelEdgePolicy) *CachedEdgePolicy

+ func (c *CachedEdgePolicy) ComputeFee(amt lnwire.MilliAtom) lnwire.MilliAtom

+ func (c *CachedEdgePolicy) ComputeFeeFromIncoming(incomingAmt lnwire.MilliAtom) lnwire.MilliAtom

type ChannelGraph

+ func NewChannelGraph(db kvdb.Backend, rejectCacheSize, chanCacheSize int, ...) (*ChannelGraph, error)

+ func (c *ChannelGraph) FetchNodeFeatures(node route.Vertex) (*lnwire.FeatureVector, error)

+ func (c *ChannelGraph) ForEachNodeCacheable(cb func(kvdb.RTx, GraphCacheNode) error) error

+ func (c *ChannelGraph) ForEachNodeCached(cb func(node route.Vertex, chans map[uint64]*DirectedChannel) error) error

+ func (c *ChannelGraph) NewPathFindTx() (kvdb.RTx, error)

+ func (c *ChannelGraph) Wipe() error

type ChannelPackager

+ func (p *ChannelPackager) Wipe(tx kvdb.RwTx) error

+ type ChannelStateDB struct

+ func (c *ChannelStateDB) AbandonChannel(chanPoint *wire.OutPoint, bestHeight uint32) error

+ func (c *ChannelStateDB) DeleteChannelOpeningState(outPoint []byte) error

+ func (c *ChannelStateDB) FetchAllChannels() ([]*OpenChannel, error)

+ func (c *ChannelStateDB) FetchAllOpenChannels() ([]*OpenChannel, error)

+ func (c *ChannelStateDB) FetchChannel(tx kvdb.RTx, chanPoint wire.OutPoint) (*OpenChannel, error)

+ func (c *ChannelStateDB) FetchClosedChannel(chanID *wire.OutPoint) (*ChannelCloseSummary, error)

+ func (c *ChannelStateDB) FetchClosedChannelForID(cid lnwire.ChannelID) (*ChannelCloseSummary, error)

+ func (c *ChannelStateDB) FetchClosedChannels(pendingOnly bool) ([]*ChannelCloseSummary, error)

+ func (c *ChannelStateDB) FetchHistoricalChannel(outPoint *wire.OutPoint) (*OpenChannel, error)

+ func (c *ChannelStateDB) FetchOpenChannels(nodeID *secp256k1.PublicKey) ([]*OpenChannel, error)

+ func (c *ChannelStateDB) FetchPendingChannels() ([]*OpenChannel, error)

+ func (c *ChannelStateDB) FetchWaitingCloseChannels() ([]*OpenChannel, error)

+ func (c *ChannelStateDB) GetChannelOpeningState(outPoint []byte) ([]byte, error)

+ func (c *ChannelStateDB) GetParentDB() *DB

+ func (c *ChannelStateDB) LinkNodeDB() *LinkNodeDB

+ func (c *ChannelStateDB) MarkChanFullyClosed(chanPoint *wire.OutPoint) error

+ func (c *ChannelStateDB) PruneLinkNodes() error

+ func (c *ChannelStateDB) RestoreChannelShells(channelShells ...*ChannelShell) error

+ func (c *ChannelStateDB) SaveChannelOpeningState(outPoint, serializedState []byte) error

+ func (d *ChannelStateDB) AddToChanReestablishWaitTime(chanID lnwire.ShortChannelID, waitTime time.Duration) error

+ func (d *ChannelStateDB) GetChanReestablishWaitTime(chanID lnwire.ShortChannelID) (waitTime time.Duration, err error)

+ func (d *ChannelStateDB) ResetChanReestablishWaitTime(chanID lnwire.ShortChannelID) error

type ChannelType

+ const LeaseExpirationBit

+ func (c ChannelType) HasLeaseExpiration() bool

type DB

+ func (d *DB) CalcPaymentStats() (*PaymentCountStats, error)

+ func (d *DB) ChannelStateDB() *ChannelStateDB

+ func (d *DB) DeletePayment(paymentHash lntypes.Hash, failedHtlcsOnly bool) error

+ func (d *DB) LocalOpenChanIDs() (map[uint64]struct{}, error)

+ type DirectedChannel struct

+ Capacity dcrutil.Amount

+ ChannelID uint64

+ InPolicy *CachedEdgePolicy

+ IsNode1 bool

+ OtherNode route.Vertex

+ OutPolicySet bool

+ func (c *DirectedChannel) DeepCopy() *DirectedChannel

type FwdPackager

+ Wipe func(tx kvdb.RwTx) error

+ type GraphCache struct

+ func NewGraphCache(preAllocNumNodes int) *GraphCache

+ func (c *GraphCache) AddChannel(info *ChannelEdgeInfo, policy1 *ChannelEdgePolicy, policy2 *ChannelEdgePolicy)

+ func (c *GraphCache) AddNode(tx kvdb.RTx, node GraphCacheNode) error

+ func (c *GraphCache) AddNodeFeatures(node GraphCacheNode)

+ func (c *GraphCache) ForEachChannel(node route.Vertex, cb func(channel *DirectedChannel) error) error

+ func (c *GraphCache) ForEachNode(cb func(node route.Vertex, channels map[uint64]*DirectedChannel) error) error

+ func (c *GraphCache) GetFeatures(node route.Vertex) *lnwire.FeatureVector

+ func (c *GraphCache) RemoveChannel(node1, node2 route.Vertex, chanID uint64)

+ func (c *GraphCache) RemoveNode(node route.Vertex)

+ func (c *GraphCache) Stats() string

+ func (c *GraphCache) UpdateChannel(info *ChannelEdgeInfo)

+ func (c *GraphCache) UpdatePolicy(policy *ChannelEdgePolicy, fromNode, toNode route.Vertex, edge1 bool)

+ type GraphCacheNode interface

+ Features func() *lnwire.FeatureVector

+ ForEachChannel func(kvdb.RTx, ...) error

+ PubKey func() route.Vertex

type Invoice

+ AMPState AMPInvoiceState

type InvoiceRef

+ func InvoiceRefByAddrBlankHtlc(addr [32]byte) InvoiceRef

+ func InvoiceRefBySetIDFiltered(setID [32]byte) InvoiceRef

+ func (r InvoiceRef) Modifier() RefModifier

+ type InvoiceStateAMP struct

+ AmtPaid lnwire.MilliAtom

+ InvoiceKeys map[CircuitKey]struct{}

+ SettleDate time.Time

+ SettleIndex uint64

+ State HtlcState

type InvoiceUpdateDesc

+ SetID *SetID

type LinkNode

+ func NewLinkNode(db *LinkNodeDB, bitNet wire.CurrencyNet, pub *secp256k1.PublicKey, ...) *LinkNode

+ type LinkNodeDB struct

+ func (l *LinkNodeDB) DeleteLinkNode(identity *secp256k1.PublicKey) error

+ func (l *LinkNodeDB) FetchAllLinkNodes() ([]*LinkNode, error)

+ func (l *LinkNodeDB) FetchLinkNode(identity *secp256k1.PublicKey) (*LinkNode, error)

type OptionModifier

+ func OptionSetPreAllocCacheNumNodes(n int) OptionModifier

+ func OptionSetUseGraphCache(use bool) OptionModifier

type Options

+ PreAllocCacheNumNodes int

+ UseGraphCache bool

+ type PaymentCountStats struct

+ Failed uint64

+ HTLCAttempts uint64

+ HTLCFailed uint64

+ HTLCSettled uint64

+ OldDupePayments uint64

+ Succeeded uint64

+ Total uint64

+ type RefModifier uint8

+ const DefaultModifier

+ const HtlcSetBlankModifier

+ const HtlcSetOnlyModifier

+ type SetID [32]byte

v0.5.0

Dec 4, 2023

Changes in this version

+ var ErrEmptyHTLCSet = errors.New("cannot settle/accept empty HTLC set")

+ var ErrHTLCAlreadySettled = errors.New("htlc already settled")

+ var ErrHTLCPreimageAlreadyExists = errors.New("htlc-level preimage already exists")

+ var ErrHTLCPreimageMismatch = errors.New("htlc preimage mismatch")

+ var ErrHTLCPreimageMissing = errors.New("AMP htlc missing preimage")

+ var ErrInvoiceHasHtlcs = errors.New("cannot add invoice with htlcs")

+ var ErrLogEntryNotFound = fmt.Errorf("log entry not found")

+ var ErrMissingIndexEntry = fmt.Errorf("missing outpoint from index")

+ var ErrNoPeerBucket = errors.New("peer bucket not found")

+ var ErrUnexpectedInvoicePreimage = errors.New("unexpected invoice preimage provided on settle")

+ func DKeyLocator(r io.Reader, val interface{}, buf *[8]byte, l uint64) error

+ func EKeyLocator(w io.Writer, val interface{}, buf *[8]byte) error

+ func MakeKeyLocRecord(typ tlv.Type, keyLoc *keychain.KeyLocator) tlv.Record

+ type BlockChannelRange struct

+ Channels []lnwire.ShortChannelID

+ Height uint32

type ChannelGraph

+ func (c *ChannelGraph) IsKnownSpent(channelID uint64) (bool, error)

+ func (c *ChannelGraph) LocalOpenChanIDs() (map[uint64]struct{}, error)

+ func (c *ChannelGraph) MarkEdgeZombie(chanID uint64, pubKey1, pubKey2 [33]byte) error

+ func (c *ChannelGraph) MarkKnownSpent(channelID uint64) error

type ChannelType

+ const ZeroHtlcTxFeeBit

+ func (c ChannelType) ZeroHtlcTxFee() bool

type ContractState

+ func (c ContractState) IsFinal() bool

type DB

+ func (d *DB) AddToChanReestablishWaitTime(chanID lnwire.ShortChannelID, waitTime time.Duration) error

+ func (d *DB) DeleteInvoice(invoicesToDelete []InvoiceDeleteRef) error

+ func (d *DB) GetChanReestablishWaitTime(chanID lnwire.ShortChannelID) (waitTime time.Duration, err error)

+ func (d *DB) ReadFlapCount(pubkey route.Vertex) (*FlapCount, error)

+ func (d *DB) ResetChanReestablishWaitTime(chanID lnwire.ShortChannelID) error

+ func (d *DB) ScanInvoices(scanFunc func(lntypes.Hash, *Invoice) error, reset func()) error

+ func (d *DB) WriteFlapCounts(flapCounts map[route.Vertex]*FlapCount) error

+ type ErrDuplicateSetID struct

+ func (e ErrDuplicateSetID) Error() string

+ type FlapCount struct

+ Count uint32

+ LastFlap time.Time

type HTLCAttemptInfo

+ Hash *lntypes.Hash

+ func NewHtlcAttemptInfo(attemptID uint64, sessionKey *secp256k1.PrivateKey, route route.Route, ...) *HTLCAttemptInfo

type HtlcAcceptDesc

+ AMP *InvoiceHtlcAMPData

type Invoice

+ func (i *Invoice) HTLCSet(setID *[32]byte, state HtlcState) map[CircuitKey]*InvoiceHTLC

+ func (i *Invoice) HTLCSetCompliment(setID *[32]byte, state HtlcState) map[CircuitKey]*InvoiceHTLC

+ type InvoiceDeleteRef struct

+ AddIndex uint64

+ PayAddr *[32]byte

+ PayHash lntypes.Hash

+ SettleIndex uint64

type InvoiceHTLC

+ AMP *InvoiceHtlcAMPData

+ func (h *InvoiceHTLC) Copy() *InvoiceHTLC

+ func (h *InvoiceHTLC) IsInHTLCSet(setID *[32]byte) bool

+ type InvoiceHtlcAMPData struct

+ Hash lntypes.Hash

+ Preimage *lntypes.Preimage

+ Record record.AMP

+ func (d *InvoiceHtlcAMPData) Copy() *InvoiceHtlcAMPData

type InvoiceRef

+ func InvoiceRefByAddr(addr [32]byte) InvoiceRef

+ func InvoiceRefBySetID(setID [32]byte) InvoiceRef

+ func (r InvoiceRef) SetID() *[32]byte

type InvoiceStateUpdateDesc

+ HTLCPreimages map[CircuitKey]lntypes.Preimage

+ SetID *[32]byte

type OpenChannel

+ RevocationKeyLocator keychain.KeyLocator

+ func (c *OpenChannel) RemoveFwdPkgs(heights ...uint64) error

type OptionModifier

+ func OptionAutoCompact() OptionModifier

+ func OptionAutoCompactMinAge(minAge time.Duration) OptionModifier

+ func OptionSetBatchCommitInterval(interval time.Duration) OptionModifier

type Options

+ BatchCommitInterval time.Duration

type PaymentCreationInfo

+ PaymentIdentifier lntypes.Hash

v0.4.0

Jun 9, 2023

v0.3.8

Apr 7, 2023

Changes in this version

type OpenChannel

+ LastWasRevoke bool

v0.3.7

Oct 10, 2022

Changes in this version

+ var ErrNoPeerLastGossipMsgTS = errors.New("last gossip msg ts not recorded")

+ var ErrOutdatedLastGossipMsgTS = errors.New(...)

type DB

+ func (d *DB) ReadPeerLastGossipMsgTS(peer route.Vertex) (time.Time, error)

+ func (d *DB) UpdatePeerLastGossipMsgTS(peer route.Vertex, ts time.Time) error

v0.3.6

Aug 5, 2022

v0.3.5

Aug 4, 2022

v0.3.4

Jan 20, 2022

Changes in this version

type DB

+ func (d *DB) AccountDiscoveryDisabled() (bool, error)

+ func (d *DB) DisableAccountDiscovery() error

v0.3.4-rc2

Jan 5, 2022

v0.3.4-rc1

Dec 22, 2021

v0.3.3

Apr 23, 2021

v0.3.1

Feb 19, 2021

v0.3.0

Jan 21, 2021

Changes in this version

+ const AbsoluteThawHeightThreshold

+ var BlankPayAddr [32]byte

+ var ErrAttemptAlreadyFailed = errors.New("attempt already failed")

+ var ErrAttemptAlreadySettled = errors.New("attempt already settled")

+ var ErrDryRunMigrationOK = errors.New("dry run migration successful")

+ var ErrDuplicateNotFound = errors.New("duplicate payment not found")

+ var ErrDuplicatePayAddr = fmt.Errorf("invoice with payemnt addr already exists")

+ var ErrInvRefEquivocation = errors.New("inv ref matches multiple invoices")

+ var ErrInvoiceCannotAccept = errors.New("cannot accept invoice")

+ var ErrInvoiceCannotOpen = errors.New("cannot move invoice to open")

+ var ErrInvoicePreimageMismatch = errors.New("preimage does not match")

+ var ErrMPPPaymentAddrMismatch = errors.New("payment address mismatch")

+ var ErrMPPTotalAmountMismatch = errors.New("mp payment total amount mismatch")

+ var ErrMPPayment = errors.New("payment has MPP attempts")

+ var ErrNoChainHashBucket = errors.New("no chain hash bucket")

+ var ErrNoChannelSummaries = errors.New("channel bucket not found")

+ var ErrNoDuplicateBucket = errors.New("expected duplicate bucket")

+ var ErrNoDuplicateNestedBucket = errors.New(...)

+ var ErrNoHistoricalBucket = fmt.Errorf(...)

+ var ErrNoSequenceNumber = errors.New("sequence number not found")

+ var ErrNonMPPayment = errors.New("payment has non-MPP attempts")

+ var ErrPaymentTerminal = errors.New("payment has reached terminal condition")

+ var ErrValueExceedsAmt = errors.New(...)

+ var ErrValueMismatch = errors.New(...)

type ChannelStatus

+ var ChanStatusCoopBroadcasted ChannelStatus = 1 << 4

+ var ChanStatusLocalCloseInitiator ChannelStatus = 1 << 5

+ var ChanStatusRemoteCloseInitiator ChannelStatus = 1 << 6

type ChannelType

+ const AnchorOutputsBit

+ const DualFunderBit

+ const FrozenBit

+ const NoFundingTxBit

+ const SingleFunderBit

+ const SingleFunderTweaklessBit

+ func (c ChannelType) HasAnchors() bool

+ func (c ChannelType) HasFundingTx() bool

+ func (c ChannelType) IsDualFunder() bool

+ func (c ChannelType) IsFrozen() bool

type ContractTerm

+ Expiry time.Duration

+ Features *lnwire.FeatureVector

+ FinalCltvDelta int32

+ PaymentAddr [32]byte

+ func (c ContractTerm) String() string

type DB

+ func CreateWithBackend(backend kvdb.Backend, modifiers ...OptionModifier) (*DB, error)

+ func MakeTestDB(modifiers ...OptionModifier) (*DB, func(), error)

+ func (d *DB) FetchAllInvoicesWithPaymentHash(pendingOnly bool) ([]InvoiceWithPaymentHash, error)

+ func (d *DB) PutResolverReport(tx kvdb.RwTx, chainHash chainhash.Hash, channelOutpoint *wire.OutPoint, ...) error

+ func (d DB) FetchChannelReports(chainHash chainhash.Hash, outPoint *wire.OutPoint) ([]*ResolverReport, error)

+ func (db *DB) AbandonChannel(chanPoint *wire.OutPoint, bestHeight uint32) error

+ func (db *DB) FetchHistoricalChannel(outPoint *wire.OutPoint) (*OpenChannel, error)

+ func (db *DB) PrintStats() string

+ func (db *DB) QueryPayments(query PaymentsQuery) (PaymentsResponse, error)

+ func (db *DB) Update(f func(tx walletdb.ReadWriteTx) error) error

+ func (db *DB) View(f func(tx walletdb.ReadTx) error) error

type FailureReason

+ const FailureReasonInsufficientBalance

+ const FailureReasonPaymentDetails

+ func (r FailureReason) Error() string

+ type HTLCAttempt struct

+ Failure *HTLCFailInfo

+ Settle *HTLCSettleInfo

+ type HTLCAttemptInfo struct

+ AttemptID uint64

+ AttemptTime time.Time

+ Route route.Route

+ SessionKey *secp256k1.PrivateKey

+ type HTLCFailInfo struct

+ FailTime time.Time

+ FailureSourceIndex uint32

+ Message lnwire.FailureMessage

+ Reason HTLCFailReason

+ type HTLCFailReason byte

+ const HTLCFailInternal

+ const HTLCFailMessage

+ const HTLCFailUnknown

+ const HTLCFailUnreadable

+ type HTLCSettleInfo struct

+ Preimage lntypes.Preimage

+ SettleTime time.Time

type HtlcAcceptDesc

+ CustomRecords record.CustomSet

+ MppTotalAmt lnwire.MilliAtom

type InFlightPayment

+ Attempts []HTLCAttemptInfo

type Invoice

+ HodlInvoice bool

+ State ContractState

+ func (i *Invoice) IsPending() bool

type InvoiceHTLC

+ CustomRecords record.CustomSet

+ MppTotalAmt lnwire.MilliAtom

+ type InvoiceRef struct

+ func InvoiceRefByHash(payHash lntypes.Hash) InvoiceRef

+ func InvoiceRefByHashAndAddr(payHash lntypes.Hash, payAddr [32]byte) InvoiceRef

+ func (r InvoiceRef) PayAddr() *[32]byte

+ func (r InvoiceRef) PayHash() lntypes.Hash

+ func (r InvoiceRef) String() string

+ type InvoiceStateUpdateDesc struct

+ NewState ContractState

+ Preimage *lntypes.Preimage

type InvoiceUpdateDesc

+ AddHtlcs map[CircuitKey]*HtlcAcceptDesc

+ CancelHtlcs map[CircuitKey]struct{}

+ type InvoiceWithPaymentHash struct

+ Invoice Invoice

+ PaymentHash lntypes.Hash

+ type MPPayment struct

+ FailureReason *FailureReason

+ HTLCs []HTLCAttempt

+ Info *PaymentCreationInfo

+ SequenceNum uint64

+ Status PaymentStatus

+ func (m *MPPayment) GetAttempt(id uint64) (*HTLCAttempt, error)

+ func (m *MPPayment) InFlightHTLCs() []HTLCAttempt

+ func (m *MPPayment) SentAmt() (lnwire.MilliAtom, lnwire.MilliAtom)

+ func (m *MPPayment) TerminalInfo() (*HTLCSettleInfo, *FailureReason)

type OpenChannel

+ LocalShutdownScript lnwire.DeliveryAddress

+ RemoteShutdownScript lnwire.DeliveryAddress

+ ThawHeight uint32

+ func (c *OpenChannel) AbsoluteThawHeight() (uint32, error)

+ func (c *OpenChannel) ActiveHtlcs() []HTLC

+ func (c *OpenChannel) BalancesAtHeight(height uint64) (lnwire.MilliAtom, lnwire.MilliAtom, error)

+ func (c *OpenChannel) BroadcastedCooperative() (*wire.MsgTx, error)

+ func (c *OpenChannel) MarkCoopBroadcasted(closeTx *wire.MsgTx, locallyInitiated bool) error

+ func (c *OpenChannel) RemoteUnsignedLocalUpdates() ([]LogUpdate, error)

+ func (c *OpenChannel) UnsignedAckedUpdates() ([]LogUpdate, error)

type OptionModifier

+ func OptionClock(clock clock.Clock) OptionModifier

+ func OptionDryRunMigration(dryRun bool) OptionModifier

type PaymentControl

+ func (p *PaymentControl) FailAttempt(hash lntypes.Hash, attemptID uint64, failInfo *HTLCFailInfo) (*MPPayment, error)

+ func (p *PaymentControl) SettleAttempt(hash lntypes.Hash, attemptID uint64, settleInfo *HTLCSettleInfo) (*MPPayment, error)

type PaymentCreationInfo

+ CreationTime time.Time

+ type PaymentsQuery struct

+ IncludeIncomplete bool

+ IndexOffset uint64

+ MaxPayments uint64

+ Reversed bool

+ type PaymentsResponse struct

+ FirstIndexOffset uint64

+ LastIndexOffset uint64

+ Payments []*MPPayment

+ type ResolverOutcome uint8

+ const ResolverOutcomeAbandoned

+ const ResolverOutcomeClaimed

+ const ResolverOutcomeFirstStage

+ const ResolverOutcomeTimeout

+ const ResolverOutcomeUnclaimed

+ type ResolverReport struct

+ Amount dcrutil.Amount

+ OutPoint wire.OutPoint

+ SpendTxID *chainhash.Hash

+ type ResolverType uint8

+ const ResolverTypeAnchor

+ const ResolverTypeCommit

+ const ResolverTypeIncomingHtlc

+ const ResolverTypeOutgoingHtlc

v0.3.0-rc4

Nov 24, 2020

v0.3.0-rc3

Nov 12, 2020

v0.3.0-rc2

Oct 30, 2020

v0.3.0-rc1

Oct 16, 2020

v0.2.1

Jan 17, 2020

v0.2.0

Nov 18, 2019

Changes in this version

+ const DefaultChannelCacheSize

+ const DefaultRejectCacheSize

+ var ErrAlreadyPaid = errors.New("invoice is already paid")

+ var ErrChanAlreadyExists = fmt.Errorf("channel already exists")

+ var ErrChanBorked = fmt.Errorf("cannot mutate borked channel")

+ var ErrEdgePolicyOptionalFieldNotFound = fmt.Errorf(...)

+ var ErrInvoiceAlreadyAccepted = errors.New("invoice already accepted")

+ var ErrInvoiceAlreadyCanceled = errors.New("invoice already canceled")

+ var ErrInvoiceAlreadySettled = errors.New("invoice already settled")

+ var ErrInvoiceStillOpen = errors.New("invoice still open")

+ var ErrNoCloseTx = fmt.Errorf("no closing tx found")

+ var ErrNoRestoredChannelMutation = fmt.Errorf(...)

+ var ErrPaymentAlreadyFailed = errors.New("payment has already failed")

+ var ErrPaymentAlreadySucceeded = errors.New("payment is already succeeded")

+ var ErrPaymentInFlight = errors.New("payment is in transition")

+ var ErrPaymentNotInitiated = errors.New("payment isn't initiated")

+ var ErrUnknownPaymentStatus = errors.New("unknown payment status")

+ var ErrZombieEdge = errors.New("edge marked as zombie")

+ var UnknownPreimage lntypes.Preimage

+ func DeserializeRoute(r io.Reader) (route.Route, error)

+ func SerializeRoute(w io.Writer, r route.Route) error

type ChannelConstraints

+ CsvDelay uint16

type ChannelEdgePolicy

+ ChannelFlags lnwire.ChanUpdateChanFlags

+ MaxHTLC lnwire.MilliAtom

+ MessageFlags lnwire.ChanUpdateMsgFlags

+ func (c *ChannelEdgePolicy) ComputeFee(amt lnwire.MilliAtom) lnwire.MilliAtom

+ func (c *ChannelEdgePolicy) ComputeFeeFromIncoming(incomingAmt lnwire.MilliAtom) lnwire.MilliAtom

+ func (c *ChannelEdgePolicy) IsDisabled() bool

+ func (c *ChannelEdgePolicy) SetSigBytes(sig []byte)

type ChannelGraph

+ func (c *ChannelGraph) DeleteChannelEdges(chanIDs ...uint64) error

+ func (c *ChannelGraph) DisabledChannelIDs() ([]uint64, error)

+ func (c *ChannelGraph) ForEachNodeChannel(tx *bolt.Tx, nodePub []byte, ...) error

+ func (c *ChannelGraph) IsZombieEdge(chanID uint64) (bool, [33]byte, [33]byte)

+ func (c *ChannelGraph) MarkEdgeLive(chanID uint64) error

+ func (c *ChannelGraph) NumZombies() (uint64, error)

+ type ChannelShell struct

+ Chan *OpenChannel

+ NodeAddrs []net.Addr

type ChannelStatus

+ var ChanStatusBorked ChannelStatus = 1

+ var ChanStatusCommitBroadcasted ChannelStatus = 1 << 1

+ var ChanStatusDefault ChannelStatus

+ var ChanStatusLocalDataLoss ChannelStatus = 1 << 2

+ var ChanStatusRestored ChannelStatus = 1 << 3

type ChannelType

+ const SingleFunderTweakless

+ func (c ChannelType) IsSingleFunder() bool

+ func (c ChannelType) IsTweakless() bool

type ContractState

+ const ContractAccepted

+ const ContractCanceled

type DB

+ func (d *DB) AddrsForNode(nodePub *secp256k1.PublicKey) ([]net.Addr, error)

+ func (d *DB) CompareAndStoreAccountID(id []byte) error

+ func (d *DB) FetchChannel(chanPoint wire.OutPoint) (*OpenChannel, error)

+ func (d *DB) NextKeyFamilyIndex(keyFamily uint32) (uint32, error)

+ func (d *DB) RestoreChannelShells(channelShells ...*ChannelShell) error

+ func (d *DB) UpdateInvoice(paymentHash lntypes.Hash, callback InvoiceUpdateCallback) (*Invoice, error)

+ func (db *DB) DeletePayments() error

+ func (db *DB) FetchPayments() ([]*Payment, error)

+ type FailureReason byte

+ const FailureReasonError

+ const FailureReasonIncorrectPaymentDetails

+ const FailureReasonNoRoute

+ const FailureReasonTimeout

+ func (r FailureReason) String() string

+ type HtlcAcceptDesc struct

+ AcceptHeight int32

+ Amt lnwire.MilliAtom

+ Expiry uint32

+ type HtlcState uint8

+ const HtlcStateAccepted

+ const HtlcStateCanceled

+ const HtlcStateSettled

+ type InFlightPayment struct

+ Attempt *PaymentAttemptInfo

+ Info *PaymentCreationInfo

type Invoice

+ Expiry time.Duration

+ FinalCltvDelta int32

+ Htlcs map[CircuitKey]*InvoiceHTLC

+ type InvoiceHTLC struct

+ AcceptHeight uint32

+ AcceptTime time.Time

+ Amt lnwire.MilliAtom

+ Expiry uint32

+ ResolveTime time.Time

+ State HtlcState

+ type InvoiceUpdateCallback = func(invoice *Invoice) (*InvoiceUpdateDesc, error)

+ type InvoiceUpdateDesc struct

+ Htlcs map[CircuitKey]*HtlcAcceptDesc

+ Preimage lntypes.Preimage

+ State ContractState

type OpenChannel

+ func (c *OpenChannel) ApplyChanStatus(status ChannelStatus) error

+ func (c *OpenChannel) BroadcastedCommitment() (*wire.MsgTx, error)

+ func (c *OpenChannel) ChanSyncMsg() (*lnwire.ChannelReestablish, error)

+ func (c *OpenChannel) ClearChanStatus(status ChannelStatus) error

+ func (c *OpenChannel) HasChanStatus(status ChannelStatus) bool

+ type OptionModifier func(*Options)

+ func OptionSetChannelCacheSize(n int) OptionModifier

+ func OptionSetRejectCacheSize(n int) OptionModifier

+ func OptionSetSyncFreelist(b bool) OptionModifier

+ type Options struct

+ ChannelCacheSize int

+ NoFreelistSync bool

+ RejectCacheSize int

+ func DefaultOptions() Options

+ type Payment struct

+ Attempt *PaymentAttemptInfo

+ Failure *FailureReason

+ Info *PaymentCreationInfo

+ PaymentPreimage *lntypes.Preimage

+ Status PaymentStatus

+ type PaymentAttemptInfo struct

+ PaymentID uint64

+ Route route.Route

+ SessionKey *secp256k1.PrivateKey

+ type PaymentControl struct

+ func NewPaymentControl(db *DB) *PaymentControl

+ func (p *PaymentControl) Fail(paymentHash lntypes.Hash, reason FailureReason) (*route.Route, error)

+ func (p *PaymentControl) FetchInFlightPayments() ([]*InFlightPayment, error)

+ func (p *PaymentControl) FetchPayment(paymentHash lntypes.Hash) (*Payment, error)

+ func (p *PaymentControl) InitPayment(paymentHash lntypes.Hash, info *PaymentCreationInfo) error

+ func (p *PaymentControl) RegisterAttempt(paymentHash lntypes.Hash, attempt *PaymentAttemptInfo) error

+ func (p *PaymentControl) Success(paymentHash lntypes.Hash, preimage lntypes.Preimage) (*route.Route, error)

+ type PaymentCreationInfo struct

+ CreationDate time.Time

+ PaymentHash lntypes.Hash

+ PaymentRequest []byte

+ Value lnwire.MilliAtom

type PaymentStatus

+ const StatusFailed

+ const StatusSucceeded

+ const StatusUnknown

type UnknownElementType

+ func NewUnknownElementType(method string, el interface{}) UnknownElementType

type WitnessCache

+ func (w *WitnessCache) AddSha256Witnesses(preimages ...lntypes.Preimage) error

+ func (w *WitnessCache) DeleteSha256Witness(hash lntypes.Hash) error

+ func (w *WitnessCache) LookupSha256Witness(hash lntypes.Hash) (lntypes.Preimage, error)

v0.2.0-rc2

Nov 18, 2019

v0.2.0-rc1

Nov 6, 2019

v0.1.0

Apr 23, 2019

Changes in this version

+ const DualFunder

+ const MaxAllowedExtraOpaqueBytes

+ const MaxMemoSize

+ const MaxPaymentRequestSize

+ const MaxReceiptSize

+ const MaxResponseEvents

+ const SingleFunder

+ var ErrChannelNotFound = fmt.Errorf("channel not found")

+ var ErrClosedChannelNotFound = errors.New("unable to find closed channel summary")

+ var ErrCorruptedFwdPkg = errors.New("fwding package db has been corrupted")

+ var ErrDBReversion = fmt.Errorf("channel db cannot revert to prior version")

+ var ErrDuplicateInvoice = fmt.Errorf("invoice with payment hash already exists")

+ var ErrEdgeAlreadyExist = fmt.Errorf("edge already exist")

+ var ErrEdgeNotFound = fmt.Errorf("edge not found")

+ var ErrGraphNeverPruned = fmt.Errorf("graph never pruned")

+ var ErrGraphNoEdgesFound = fmt.Errorf("no graph edges exist")

+ var ErrGraphNodeNotFound = fmt.Errorf("unable to find node")

+ var ErrGraphNodesNotFound = fmt.Errorf("no graph nodes exist")

+ var ErrGraphNotFound = fmt.Errorf("graph bucket not initialized")

+ var ErrInvalidCircuitKeyLen = fmt.Errorf("length of serialized circuit key must be 16 bytes")

+ var ErrInvoiceNotFound = fmt.Errorf("unable to locate invoice")

+ var ErrLinkNodesNotFound = fmt.Errorf("no link nodes exist")

+ var ErrMetaNotFound = fmt.Errorf("unable to locate meta information")

+ var ErrNoActiveChannels = fmt.Errorf("no active channels exist")

+ var ErrNoChanDBExists = fmt.Errorf("channel db has not yet been created")

+ var ErrNoChanInfoFound = fmt.Errorf("no chan info found")

+ var ErrNoClosedChannels = fmt.Errorf("no channel have been closed yet")

+ var ErrNoCommitPoint = fmt.Errorf("no commit point found")

+ var ErrNoCommitmentsFound = fmt.Errorf("no commitments found")

+ var ErrNoForwardingEvents = fmt.Errorf("no recorded forwarding events")

+ var ErrNoInvoicesCreated = fmt.Errorf("there are no existing invoices")

+ var ErrNoPastDeltas = fmt.Errorf("channel has no recorded deltas")

+ var ErrNoPaymentsCreated = fmt.Errorf("there are no existing payments")

+ var ErrNoPendingCommit = fmt.Errorf("no pending commits found")

+ var ErrNoRevocationsFound = fmt.Errorf("no revocations found")

+ var ErrNoWitnesses = fmt.Errorf("no witnesses")

+ var ErrNodeAliasNotFound = fmt.Errorf("alias for node not found")

+ var ErrNodeNotFound = fmt.Errorf("link node with target identity not found")

+ var ErrSourceNodeNotSet = fmt.Errorf("source node does not exist")

+ var ErrUnknownAddressType = fmt.Errorf("address type cannot be resolved")

+ var ErrUnknownWitnessType = fmt.Errorf("unknown witness type")

+ var ErrWaitingProofAlreadyExist = errors.New(...)

+ var ErrWaitingProofNotFound = errors.New(...)

+ func DisableLog()

+ func ErrTooManyExtraOpaqueBytes(numBytes int) error

+ func ReadElement(r io.Reader, element interface{}) error

+ func ReadElements(r io.Reader, elements ...interface{}) error

+ func SerializeHtlcs(b io.Writer, htlcs ...HTLC) error

+ func UpdatePaymentStatusTx(tx *bolt.Tx, paymentHash [32]byte, status PaymentStatus) error

+ func UseLogger(logger slog.Logger)

+ func WriteElement(w io.Writer, element interface{}) error

+ func WriteElements(w io.Writer, elements ...interface{}) error

+ type AddRef struct

+ Height uint64

+ Index uint16

+ func (a *AddRef) Decode(r io.Reader) error

+ func (a *AddRef) Encode(w io.Writer) error

+ type ChannelAuthProof struct

+ DecredSig1Bytes []byte

+ DecredSig2Bytes []byte

+ NodeSig1Bytes []byte

+ NodeSig2Bytes []byte

+ func (c *ChannelAuthProof) DecredSig1() (*secp256k1.Signature, error)

+ func (c *ChannelAuthProof) DecredSig2() (*secp256k1.Signature, error)

+ func (c *ChannelAuthProof) IsEmpty() bool

+ func (c *ChannelAuthProof) Node1Sig() (*secp256k1.Signature, error)

+ func (c *ChannelAuthProof) Node2Sig() (*secp256k1.Signature, error)

+ type ChannelCloseSummary struct

+ Capacity dcrutil.Amount

+ ChainHash chainhash.Hash

+ ChanPoint wire.OutPoint

+ CloseHeight uint32

+ CloseType ClosureType

+ ClosingTXID chainhash.Hash

+ IsPending bool

+ LastChanSyncMsg *lnwire.ChannelReestablish

+ LocalChanConfig ChannelConfig

+ RemoteCurrentRevocation *secp256k1.PublicKey

+ RemoteNextRevocation *secp256k1.PublicKey

+ RemotePub *secp256k1.PublicKey

+ SettledBalance dcrutil.Amount

+ ShortChanID lnwire.ShortChannelID

+ TimeLockedBalance dcrutil.Amount

+ type ChannelCommitment struct

+ CommitFee dcrutil.Amount

+ CommitHeight uint64

+ CommitSig []byte

+ CommitTx *wire.MsgTx

+ FeePerKB dcrutil.Amount

+ Htlcs []HTLC

+ LocalBalance lnwire.MilliAtom

+ LocalHtlcIndex uint64

+ LocalLogIndex uint64

+ RemoteBalance lnwire.MilliAtom

+ RemoteHtlcIndex uint64

+ RemoteLogIndex uint64

+ type ChannelConfig struct

+ CsvDelay uint16

+ DelayBasePoint keychain.KeyDescriptor

+ HtlcBasePoint keychain.KeyDescriptor

+ MultiSigKey keychain.KeyDescriptor

+ PaymentBasePoint keychain.KeyDescriptor

+ RevocationBasePoint keychain.KeyDescriptor

+ type ChannelConstraints struct

+ ChanReserve dcrutil.Amount

+ DustLimit dcrutil.Amount

+ MaxAcceptedHtlcs uint16

+ MaxPendingAmount lnwire.MilliAtom

+ MinHTLC lnwire.MilliAtom

+ type ChannelEdge struct

+ Info *ChannelEdgeInfo

+ Policy1 *ChannelEdgePolicy

+ Policy2 *ChannelEdgePolicy

+ type ChannelEdgeInfo struct

+ AuthProof *ChannelAuthProof

+ Capacity dcrutil.Amount

+ ChainHash chainhash.Hash

+ ChannelID uint64

+ ChannelPoint wire.OutPoint

+ DecredKey1Bytes [33]byte

+ DecredKey2Bytes [33]byte

+ ExtraOpaqueData []byte

+ Features []byte

+ NodeKey1Bytes [33]byte

+ NodeKey2Bytes [33]byte

+ func (c *ChannelEdgeInfo) AddNodeKeys(nodeKey1, nodeKey2, bitcoinKey1, bitcoinKey2 *secp256k1.PublicKey)

+ func (c *ChannelEdgeInfo) DecredKey1() (*secp256k1.PublicKey, error)

+ func (c *ChannelEdgeInfo) DecredKey2() (*secp256k1.PublicKey, error)

+ func (c *ChannelEdgeInfo) FetchOtherNode(tx *bolt.Tx, thisNodeKey []byte) (*LightningNode, error)

+ func (c *ChannelEdgeInfo) NodeKey1() (*secp256k1.PublicKey, error)

+ func (c *ChannelEdgeInfo) NodeKey2() (*secp256k1.PublicKey, error)

+ func (c *ChannelEdgeInfo) OtherNodeKeyBytes(thisNodeKey []byte) ([]byte, error)

+ type ChannelEdgePolicy struct

+ ChannelID uint64

+ ExtraOpaqueData []byte

+ FeeBaseMAtoms lnwire.MilliAtom

+ FeeProportionalMillionths lnwire.MilliAtom

+ Flags lnwire.ChanUpdateFlag

+ LastUpdate time.Time

+ MinHTLC lnwire.MilliAtom

+ Node *LightningNode

+ SigBytes []byte

+ TimeLockDelta uint16

+ func (c *ChannelEdgePolicy) Signature() (*secp256k1.Signature, error)

+ type ChannelGraph struct

+ func (c *ChannelGraph) AddChannelEdge(edge *ChannelEdgeInfo) error

+ func (c *ChannelGraph) AddLightningNode(node *LightningNode) error

+ func (c *ChannelGraph) ChanUpdatesInHorizon(startTime, endTime time.Time) ([]ChannelEdge, error)

+ func (c *ChannelGraph) ChannelID(chanPoint *wire.OutPoint) (uint64, error)

+ func (c *ChannelGraph) ChannelView() ([]EdgePoint, error)

+ func (c *ChannelGraph) Database() *DB

+ func (c *ChannelGraph) DeleteChannelEdge(chanPoint *wire.OutPoint) error

+ func (c *ChannelGraph) DeleteLightningNode(nodePub *secp256k1.PublicKey) error

+ func (c *ChannelGraph) DisconnectBlockAtHeight(height uint32) ([]*ChannelEdgeInfo, error)

+ func (c *ChannelGraph) FetchChanInfos(chanIDs []uint64) ([]ChannelEdge, error)

+ func (c *ChannelGraph) FetchChannelEdgesByID(chanID uint64) (*ChannelEdgeInfo, *ChannelEdgePolicy, *ChannelEdgePolicy, error)

+ func (c *ChannelGraph) FetchChannelEdgesByOutpoint(op *wire.OutPoint) (*ChannelEdgeInfo, *ChannelEdgePolicy, *ChannelEdgePolicy, error)

+ func (c *ChannelGraph) FetchLightningNode(pub *secp256k1.PublicKey) (*LightningNode, error)

+ func (c *ChannelGraph) FilterChannelRange(startHeight, endHeight uint32) ([]uint64, error)

+ func (c *ChannelGraph) FilterKnownChanIDs(chanIDs []uint64) ([]uint64, error)

+ func (c *ChannelGraph) ForEachChannel(cb func(*ChannelEdgeInfo, *ChannelEdgePolicy, *ChannelEdgePolicy) error) error

+ func (c *ChannelGraph) ForEachNode(tx *bolt.Tx, cb func(*bolt.Tx, *LightningNode) error) error

+ func (c *ChannelGraph) HasChannelEdge(chanID uint64) (time.Time, time.Time, bool, error)

+ func (c *ChannelGraph) HasLightningNode(nodePub [33]byte) (time.Time, bool, error)

+ func (c *ChannelGraph) HighestChanID() (uint64, error)

+ func (c *ChannelGraph) IsPublicNode(pubKey [33]byte) (bool, error)

+ func (c *ChannelGraph) LookupAlias(pub *secp256k1.PublicKey) (string, error)

+ func (c *ChannelGraph) NewChannelEdgePolicy() *ChannelEdgePolicy

+ func (c *ChannelGraph) NodeUpdatesInHorizon(startTime, endTime time.Time) ([]LightningNode, error)

+ func (c *ChannelGraph) PruneGraph(spentOutputs []*wire.OutPoint, blockHash *chainhash.Hash, blockHeight uint32) ([]*ChannelEdgeInfo, error)

+ func (c *ChannelGraph) PruneGraphNodes() error

+ func (c *ChannelGraph) PruneTip() (*chainhash.Hash, uint32, error)

+ func (c *ChannelGraph) SetSourceNode(node *LightningNode) error

+ func (c *ChannelGraph) SourceNode() (*LightningNode, error)

+ func (c *ChannelGraph) UpdateChannelEdge(edge *ChannelEdgeInfo) error

+ func (c *ChannelGraph) UpdateEdgePolicy(edge *ChannelEdgePolicy) error

+ type ChannelPackager struct

+ func NewChannelPackager(source lnwire.ShortChannelID) *ChannelPackager

+ func (*ChannelPackager) AddFwdPkg(tx *bolt.Tx, fwdPkg *FwdPkg) error

+ func (p *ChannelPackager) AckAddHtlcs(tx *bolt.Tx, addRefs ...AddRef) error

+ func (p *ChannelPackager) AckSettleFails(tx *bolt.Tx, settleFailRefs ...SettleFailRef) error

+ func (p *ChannelPackager) LoadFwdPkgs(tx *bolt.Tx) ([]*FwdPkg, error)

+ func (p *ChannelPackager) RemovePkg(tx *bolt.Tx, height uint64) error

+ func (p *ChannelPackager) SetFwdFilter(tx *bolt.Tx, height uint64, fwdFilter *PkgFilter) error

+ type ChannelSnapshot struct

+ Capacity dcrutil.Amount

+ ChainHash chainhash.Hash

+ ChannelPoint wire.OutPoint

+ RemoteIdentity secp256k1.PublicKey

+ TotalMAtomsReceived lnwire.MilliAtom

+ TotalMAtomsSent lnwire.MilliAtom

+ type ChannelStatus uint8

+ var Borked ChannelStatus = 1

+ var CommitmentBroadcasted ChannelStatus = 1 << 1

+ var Default ChannelStatus

+ var LocalDataLoss ChannelStatus = 1 << 2

+ func (c ChannelStatus) String() string

+ type ChannelType uint8

+ type CircuitKey struct

+ ChanID lnwire.ShortChannelID

+ HtlcID uint64

+ func (k *CircuitKey) Decode(r io.Reader) error

+ func (k *CircuitKey) Encode(w io.Writer) error

+ func (k *CircuitKey) SetBytes(bs []byte) error

+ func (k CircuitKey) Bytes() []byte

+ func (k CircuitKey) String() string

+ type ClosureType uint8

+ const Abandoned

+ const BreachClose

+ const CooperativeClose

+ const FundingCanceled

+ const LocalForceClose

+ const RemoteForceClose

+ type CommitDiff struct

+ AddAcks []AddRef

+ ClosedCircuitKeys []CircuitKey

+ CommitSig *lnwire.CommitSig

+ Commitment ChannelCommitment

+ LogUpdates []LogUpdate

+ OpenedCircuitKeys []CircuitKey

+ SettleFailAcks []SettleFailRef

+ type ContractState uint8

+ const ContractOpen

+ const ContractSettled

+ func (c ContractState) String() string

+ type ContractTerm struct

+ PaymentPreimage [32]byte

+ State ContractState

+ Value lnwire.MilliAtom

+ type DB struct

+ func Open(dbPath string) (*DB, error)

+ func (d *DB) AddInvoice(newInvoice *Invoice) (uint64, error)

+ func (d *DB) ChannelGraph() *ChannelGraph

+ func (d *DB) FetchAllChannels() ([]*OpenChannel, error)

+ func (d *DB) FetchAllInvoices(pendingOnly bool) ([]Invoice, error)

+ func (d *DB) FetchAllOpenChannels() ([]*OpenChannel, error)

+ func (d *DB) FetchClosedChannel(chanID *wire.OutPoint) (*ChannelCloseSummary, error)

+ func (d *DB) FetchClosedChannelForID(cid lnwire.ChannelID) (*ChannelCloseSummary, error)

+ func (d *DB) FetchClosedChannels(pendingOnly bool) ([]*ChannelCloseSummary, error)

+ func (d *DB) FetchMeta(tx *bolt.Tx) (*Meta, error)

+ func (d *DB) FetchOpenChannels(nodeID *secp256k1.PublicKey) ([]*OpenChannel, error)

+ func (d *DB) FetchPendingChannels() ([]*OpenChannel, error)

+ func (d *DB) FetchWaitingCloseChannels() ([]*OpenChannel, error)

+ func (d *DB) ForwardingLog() *ForwardingLog

+ func (d *DB) InvoicesAddedSince(sinceAddIndex uint64) ([]Invoice, error)

+ func (d *DB) InvoicesSettledSince(sinceSettleIndex uint64) ([]Invoice, error)

+ func (d *DB) LookupInvoice(paymentHash [32]byte) (Invoice, error)

+ func (d *DB) MarkChanFullyClosed(chanPoint *wire.OutPoint) error

+ func (d *DB) NewWitnessCache() *WitnessCache

+ func (d *DB) Path() string

+ func (d *DB) PruneLinkNodes() error

+ func (d *DB) PutMeta(meta *Meta) error

+ func (d *DB) QueryInvoices(q InvoiceQuery) (InvoiceSlice, error)

+ func (d *DB) SettleInvoice(paymentHash [32]byte, amtPaid lnwire.MilliAtom) (*Invoice, error)

+ func (d *DB) Wipe() error

+ func (db *DB) AddPayment(payment *OutgoingPayment) error

+ func (db *DB) DeleteAllPayments() error

+ func (db *DB) DeleteLinkNode(identity *secp256k1.PublicKey) error

+ func (db *DB) FetchAllLinkNodes() ([]*LinkNode, error)

+ func (db *DB) FetchAllPayments() ([]*OutgoingPayment, error)

+ func (db *DB) FetchLinkNode(identity *secp256k1.PublicKey) (*LinkNode, error)

+ func (db *DB) FetchPaymentStatus(paymentHash [32]byte) (PaymentStatus, error)

+ func (db *DB) NewLinkNode(bitNet wire.CurrencyNet, pub *secp256k1.PublicKey, addr net.Addr) *LinkNode

+ func (db *DB) UpdatePaymentStatus(paymentHash [32]byte, status PaymentStatus) error

+ type EdgePoint struct

+ FundingPkScript []byte

+ OutPoint wire.OutPoint

+ func (e *EdgePoint) String() string

+ type ForwardingEvent struct

+ AmtIn lnwire.MilliAtom

+ AmtOut lnwire.MilliAtom

+ IncomingChanID lnwire.ShortChannelID

+ OutgoingChanID lnwire.ShortChannelID

+ Timestamp time.Time

+ type ForwardingEventQuery struct

+ EndTime time.Time

+ IndexOffset uint32

+ NumMaxEvents uint32

+ StartTime time.Time

+ type ForwardingLog struct

+ func (f *ForwardingLog) AddForwardingEvents(events []ForwardingEvent) error

+ func (f *ForwardingLog) Query(q ForwardingEventQuery) (ForwardingLogTimeSlice, error)

+ type ForwardingLogTimeSlice struct

+ ForwardingEvents []ForwardingEvent

+ LastIndexOffset uint32

+ type FwdOperator interface

+ type FwdPackager interface

+ AckAddHtlcs func(tx *bolt.Tx, addRefs ...AddRef) error

+ AddFwdPkg func(tx *bolt.Tx, fwdPkg *FwdPkg) error

+ LoadFwdPkgs func(tx *bolt.Tx) ([]*FwdPkg, error)

+ RemovePkg func(tx *bolt.Tx, height uint64) error

+ SetFwdFilter func(tx *bolt.Tx, height uint64, fwdFilter *PkgFilter) error

+ type FwdPkg struct

+ AckFilter *PkgFilter

+ Adds []LogUpdate

+ FwdFilter *PkgFilter

+ Height uint64

+ SettleFailFilter *PkgFilter

+ SettleFails []LogUpdate

+ Source lnwire.ShortChannelID

+ State FwdState

+ func NewFwdPkg(source lnwire.ShortChannelID, height uint64, ...) *FwdPkg

+ func (f *FwdPkg) ID() []byte

+ func (f *FwdPkg) String() string

+ type FwdState byte

+ const FwdStateCompleted

+ const FwdStateLockedIn

+ const FwdStateProcessed

+ type GlobalFwdPkgReader interface

+ LoadChannelFwdPkgs func(tx *bolt.Tx, source lnwire.ShortChannelID) ([]*FwdPkg, error)

+ type HTLC struct

+ Amt lnwire.MilliAtom

+ HtlcIndex uint64

+ Incoming bool

+ LogIndex uint64

+ OnionBlob []byte

+ OutputIndex int32

+ RHash [32]byte

+ RefundTimeout uint32

+ Signature []byte

+ func DeserializeHtlcs(r io.Reader) ([]HTLC, error)

+ func (h *HTLC) Copy() HTLC

+ type Invoice struct

+ AddIndex uint64

+ AmtPaid lnwire.MilliAtom

+ CreationDate time.Time

+ Memo []byte

+ PaymentRequest []byte

+ Receipt []byte

+ SettleDate time.Time

+ SettleIndex uint64

+ Terms ContractTerm

+ type InvoiceQuery struct

+ IndexOffset uint64

+ NumMaxInvoices uint64

+ PendingOnly bool

+ Reversed bool

+ type InvoiceSlice struct

+ FirstIndexOffset uint64

+ Invoices []Invoice

+ LastIndexOffset uint64

+ type LightningNode struct

+ Addresses []net.Addr

+ Alias string

+ AuthSigBytes []byte

+ Color color.RGBA

+ ExtraOpaqueData []byte

+ Features *lnwire.FeatureVector

+ HaveNodeAnnouncement bool

+ LastUpdate time.Time

+ PubKeyBytes [33]byte

+ func (l *LightningNode) AddPubKey(key *secp256k1.PublicKey)

+ func (l *LightningNode) AuthSig() (*secp256k1.Signature, error)

+ func (l *LightningNode) ForEachChannel(tx *bolt.Tx, ...) error

+ func (l *LightningNode) NodeAnnouncement(signed bool) (*lnwire.NodeAnnouncement, error)

+ func (l *LightningNode) PubKey() (*secp256k1.PublicKey, error)

+ type LinkNode struct

+ Addresses []net.Addr

+ IdentityPub *secp256k1.PublicKey

+ LastSeen time.Time

+ Network wire.CurrencyNet

+ func (l *LinkNode) AddAddress(addr net.Addr) error

+ func (l *LinkNode) Sync() error

+ func (l *LinkNode) UpdateLastSeen(lastSeen time.Time) error

+ type LogUpdate struct

+ LogIndex uint64

+ UpdateMsg lnwire.Message

+ func (l *LogUpdate) Decode(r io.Reader) error

+ func (l *LogUpdate) Encode(w io.Writer) error

+ type Meta struct

+ DbVersionNumber uint32

+ type OpenChannel struct

+ Capacity dcrutil.Amount

+ ChainHash chainhash.Hash

+ ChanType ChannelType

+ ChannelFlags lnwire.FundingFlag

+ Db *DB

+ FundingBroadcastHeight uint32

+ FundingOutpoint wire.OutPoint

+ FundingTxn *wire.MsgTx

+ IdentityPub *secp256k1.PublicKey

+ IsInitiator bool

+ IsPending bool

+ LocalChanCfg ChannelConfig

+ LocalCommitment ChannelCommitment

+ NumConfsRequired uint16

+ Packager FwdPackager

+ RemoteChanCfg ChannelConfig

+ RemoteCommitment ChannelCommitment

+ RemoteCurrentRevocation *secp256k1.PublicKey

+ RemoteNextRevocation *secp256k1.PublicKey

+ RevocationProducer shachain.Producer

+ RevocationStore shachain.Store

+ ShortChannelID lnwire.ShortChannelID

+ TotalMAtomsReceived lnwire.MilliAtom

+ TotalMAtomsSent lnwire.MilliAtom

+ func (c *OpenChannel) AckAddHtlcs(addRefs ...AddRef) error

+ func (c *OpenChannel) AckSettleFails(settleFailRefs ...SettleFailRef) error

+ func (c *OpenChannel) AdvanceCommitChainTail(fwdPkg *FwdPkg) error

+ func (c *OpenChannel) AppendRemoteCommitChain(diff *CommitDiff) error

+ func (c *OpenChannel) ChanStatus() ChannelStatus

+ func (c *OpenChannel) CloseChannel(summary *ChannelCloseSummary) error

+ func (c *OpenChannel) CommitmentHeight() (uint64, error)

+ func (c *OpenChannel) DataLossCommitPoint() (*secp256k1.PublicKey, error)

+ func (c *OpenChannel) FindPreviousState(updateNum uint64) (*ChannelCommitment, error)

+ func (c *OpenChannel) FullSync() error

+ func (c *OpenChannel) InsertNextRevocation(revKey *secp256k1.PublicKey) error

+ func (c *OpenChannel) LatestCommitments() (*ChannelCommitment, *ChannelCommitment, error)

+ func (c *OpenChannel) LoadFwdPkgs() ([]*FwdPkg, error)

+ func (c *OpenChannel) MarkAsOpen(openLoc lnwire.ShortChannelID) error

+ func (c *OpenChannel) MarkBorked() error

+ func (c *OpenChannel) MarkCommitmentBroadcasted() error

+ func (c *OpenChannel) MarkDataLoss(commitPoint *secp256k1.PublicKey) error

+ func (c *OpenChannel) NextLocalHtlcIndex() (uint64, error)

+ func (c *OpenChannel) RefreshShortChanID() error

+ func (c *OpenChannel) RemoteCommitChainTip() (*CommitDiff, error)

+ func (c *OpenChannel) RemoteRevocationStore() (shachain.Store, error)

+ func (c *OpenChannel) RemoveFwdPkg(height uint64) error

+ func (c *OpenChannel) RevocationLogTail() (*ChannelCommitment, error)

+ func (c *OpenChannel) SetFwdFilter(height uint64, fwdFilter *PkgFilter) error

+ func (c *OpenChannel) ShortChanID() lnwire.ShortChannelID

+ func (c *OpenChannel) Snapshot() *ChannelSnapshot

+ func (c *OpenChannel) SyncPending(addr net.Addr, pendingHeight uint32) error

+ func (c *OpenChannel) UpdateCommitment(newCommitment *ChannelCommitment) error

+ type OutgoingPayment struct

+ Fee lnwire.MilliAtom

+ Path [][33]byte

+ PaymentPreimage [32]byte

+ TimeLockLength uint32

+ type PaymentStatus byte

+ const StatusCompleted

+ const StatusGrounded

+ const StatusInFlight

+ func FetchPaymentStatusTx(tx *bolt.Tx, paymentHash [32]byte) (PaymentStatus, error)

+ func (ps *PaymentStatus) FromBytes(status []byte) error

+ func (ps PaymentStatus) Bytes() []byte

+ func (ps PaymentStatus) String() string

+ type PkgFilter struct

+ func NewPkgFilter(count uint16) *PkgFilter

+ func (f *PkgFilter) Contains(i uint16) bool

+ func (f *PkgFilter) Count() uint16

+ func (f *PkgFilter) Decode(r io.Reader) error

+ func (f *PkgFilter) Encode(w io.Writer) error

+ func (f *PkgFilter) Equal(f2 *PkgFilter) bool

+ func (f *PkgFilter) IsFull() bool

+ func (f *PkgFilter) Set(i uint16)

+ func (f *PkgFilter) Size() uint16

+ type SettleFailAcker interface

+ AckSettleFails func(tx *bolt.Tx, settleFailRefs ...SettleFailRef) error

+ type SettleFailRef struct

+ Height uint64

+ Index uint16

+ Source lnwire.ShortChannelID

+ type SwitchPackager struct

+ func NewSwitchPackager() *SwitchPackager

+ func (*SwitchPackager) AckSettleFails(tx *bolt.Tx, settleFailRefs ...SettleFailRef) error

+ func (*SwitchPackager) LoadChannelFwdPkgs(tx *bolt.Tx, source lnwire.ShortChannelID) ([]*FwdPkg, error)

+ type UnknownElementType struct

+ func (e UnknownElementType) Error() string

+ type WaitingProof struct

+ func NewWaitingProof(isRemote bool, proof *lnwire.AnnounceSignatures) *WaitingProof

+ func (p *WaitingProof) Decode(r io.Reader) error

+ func (p *WaitingProof) Encode(w io.Writer) error

+ func (p *WaitingProof) Key() WaitingProofKey

+ func (p *WaitingProof) OppositeKey() WaitingProofKey

+ type WaitingProofKey [9]byte

+ type WaitingProofStore struct

+ func NewWaitingProofStore(db *DB) (*WaitingProofStore, error)

+ func (s *WaitingProofStore) Add(proof *WaitingProof) error

+ func (s *WaitingProofStore) ForAll(cb func(*WaitingProof) error) error

+ func (s *WaitingProofStore) Get(key WaitingProofKey) (*WaitingProof, error)

+ func (s *WaitingProofStore) Remove(key WaitingProofKey) error

+ type WitnessCache struct

+ func (w *WitnessCache) AddWitness(wType WitnessType, witness []byte) error

+ func (w *WitnessCache) DeleteWitness(wType WitnessType, witnessKey []byte) error

+ func (w *WitnessCache) DeleteWitnessClass(wType WitnessType) error

+ func (w *WitnessCache) LookupWitness(wType WitnessType, witnessKey []byte) ([]byte, error)

+ type WitnessType uint8

+ var Sha256HashWitness WitnessType = 1

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL