channeldb

package

Go to main page

Versions in this module

v0

v0.5.1

Feb 26, 2020

Changes in this version

+ const DefaultChannelCacheSize

+ const DefaultRejectCacheSize

+ const MaxAllowedExtraOpaqueBytes

+ const MaxPaymentRequestSize

+ const MaxResponseEvents

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

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

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

+ 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 ErrEdgeAlreadyExist = fmt.Errorf("edge already exist")

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

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

+ 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 ErrInvoiceAlreadyAccepted = errors.New("invoice already accepted")

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

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

+ 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 ErrInvoiceStillOpen = errors.New("invoice still open")

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

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

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

+ var ErrNoCloseTx = fmt.Errorf("no closing tx 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 ErrNoHistoricalBucket = fmt.Errorf(...)

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

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

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

+ 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 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 ErrSourceNodeNotSet = fmt.Errorf("source node does not exist")

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

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

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

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

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

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

+ var UnknownPreimage lntypes.Preimage

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

+ 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 SerializeRoute(w io.Writer, r route.Route) error

+ 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

+ BitcoinSig1Bytes []byte

+ BitcoinSig2Bytes []byte

+ NodeSig1Bytes []byte

+ NodeSig2Bytes []byte

+ func (c *ChannelAuthProof) BitcoinSig1() (*btcec.Signature, error)

+ func (c *ChannelAuthProof) BitcoinSig2() (*btcec.Signature, error)

+ func (c *ChannelAuthProof) IsEmpty() bool

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

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

+ type ChannelCloseSummary struct

+ Capacity btcutil.Amount

+ ChainHash chainhash.Hash

+ ChanPoint wire.OutPoint

+ CloseHeight uint32

+ CloseType ClosureType

+ ClosingTXID chainhash.Hash

+ IsPending bool

+ LastChanSyncMsg *lnwire.ChannelReestablish

+ LocalChanConfig ChannelConfig

+ RemoteCurrentRevocation *btcec.PublicKey

+ RemoteNextRevocation *btcec.PublicKey

+ RemotePub *btcec.PublicKey

+ SettledBalance btcutil.Amount

+ ShortChanID lnwire.ShortChannelID

+ TimeLockedBalance btcutil.Amount

+ type ChannelCommitment struct

+ CommitFee btcutil.Amount

+ CommitHeight uint64

+ CommitSig []byte

+ CommitTx *wire.MsgTx

+ FeePerKw btcutil.Amount

+ Htlcs []HTLC

+ LocalBalance lnwire.MilliSatoshi

+ LocalHtlcIndex uint64

+ LocalLogIndex uint64

+ RemoteBalance lnwire.MilliSatoshi

+ RemoteHtlcIndex uint64

+ RemoteLogIndex uint64

+ type ChannelConfig struct

+ DelayBasePoint keychain.KeyDescriptor

+ HtlcBasePoint keychain.KeyDescriptor

+ MultiSigKey keychain.KeyDescriptor

+ PaymentBasePoint keychain.KeyDescriptor

+ RevocationBasePoint keychain.KeyDescriptor

+ type ChannelConstraints struct

+ ChanReserve btcutil.Amount

+ CsvDelay uint16

+ DustLimit btcutil.Amount

+ MaxAcceptedHtlcs uint16

+ MaxPendingAmount lnwire.MilliSatoshi

+ MinHTLC lnwire.MilliSatoshi

+ type ChannelEdge struct

+ Info *ChannelEdgeInfo

+ Policy1 *ChannelEdgePolicy

+ Policy2 *ChannelEdgePolicy

+ type ChannelEdgeInfo struct

+ AuthProof *ChannelAuthProof

+ BitcoinKey1Bytes [33]byte

+ BitcoinKey2Bytes [33]byte

+ Capacity btcutil.Amount

+ ChainHash chainhash.Hash

+ ChannelID uint64

+ ChannelPoint wire.OutPoint

+ ExtraOpaqueData []byte

+ Features []byte

+ NodeKey1Bytes [33]byte

+ NodeKey2Bytes [33]byte

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

+ func (c *ChannelEdgeInfo) BitcoinKey1() (*btcec.PublicKey, error)

+ func (c *ChannelEdgeInfo) BitcoinKey2() (*btcec.PublicKey, error)

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

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

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

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

+ type ChannelEdgePolicy struct

+ ChannelFlags lnwire.ChanUpdateChanFlags

+ ChannelID uint64

+ ExtraOpaqueData []byte

+ FeeBaseMSat lnwire.MilliSatoshi

+ FeeProportionalMillionths lnwire.MilliSatoshi

+ LastUpdate time.Time

+ MaxHTLC lnwire.MilliSatoshi

+ MessageFlags lnwire.ChanUpdateMsgFlags

+ MinHTLC lnwire.MilliSatoshi

+ Node *LightningNode

+ SigBytes []byte

+ TimeLockDelta uint16

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

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

+ func (c *ChannelEdgePolicy) IsDisabled() bool

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

+ func (c *ChannelEdgePolicy) Signature() (*btcec.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) DeleteChannelEdges(chanIDs ...uint64) error

+ func (c *ChannelGraph) DeleteLightningNode(nodePub route.Vertex) error

+ func (c *ChannelGraph) DisabledChannelIDs() ([]uint64, 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(tx *bbolt.Tx, nodePub route.Vertex) (*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 *bbolt.Tx, cb func(*bbolt.Tx, *LightningNode) error) error

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

+ func (c *ChannelGraph) HasChannelEdge(chanID uint64) (time.Time, time.Time, bool, 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) IsZombieEdge(chanID uint64) (bool, [33]byte, [33]byte)

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

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

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

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

+ func (c *ChannelGraph) NumZombies() (uint64, 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 *bbolt.Tx, fwdPkg *FwdPkg) error

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

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

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

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

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

+ type ChannelShell struct

+ Chan *OpenChannel

+ NodeAddrs []net.Addr

type ChannelSnapshot

+ ChainHash chainhash.Hash

+ RemoteIdentity btcec.PublicKey

+ TotalMSatReceived lnwire.MilliSatoshi

+ TotalMSatSent lnwire.MilliSatoshi

+ type ChannelStatus uint8

+ var ChanStatusBorked ChannelStatus = 1

+ var ChanStatusCommitBroadcasted ChannelStatus = 1 << 1

+ var ChanStatusCoopBroadcasted ChannelStatus = 1 << 4

+ var ChanStatusDefault ChannelStatus

+ var ChanStatusLocalCloseInitiator ChannelStatus = 1 << 5

+ var ChanStatusLocalDataLoss ChannelStatus = 1 << 2

+ var ChanStatusRemoteCloseInitiator ChannelStatus = 1 << 6

+ var ChanStatusRestored ChannelStatus = 1 << 3

+ func (c ChannelStatus) String() string

+ type ChannelType uint8

+ const DualFunderBit

+ const NoFundingTxBit

+ const SingleFunderBit

+ const SingleFunderTweaklessBit

+ func (c ChannelType) HasFundingTx() bool

+ func (c ChannelType) IsDualFunder() bool

+ func (c ChannelType) IsSingleFunder() bool

+ func (c ChannelType) IsTweakless() bool

+ 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 ContractAccepted

+ const ContractCanceled

+ const ContractOpen

+ const ContractSettled

+ func (c ContractState) String() string

type ContractTerm

+ Expiry time.Duration

+ Features *lnwire.FeatureVector

+ FinalCltvDelta int32

+ PaymentAddr [32]byte

type DB

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

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

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

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

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

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

+ func (d *DB) FetchChannel(chanPoint wire.OutPoint) (*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) FetchHistoricalChannel(outPoint *wire.OutPoint) (*OpenChannel, error)

+ func (d *DB) FetchMeta(tx *bbolt.Tx) (*Meta, 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) 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) RestoreChannelShells(channelShells ...*ChannelShell) error

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

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

+ func (db *DB) DeletePayments() error

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

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

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

+ func (db *DB) NewLinkNode(bitNet wire.BitcoinNet, pub *btcec.PublicKey, addrs ...net.Addr) *LinkNode

+ type EdgePoint struct

+ FundingPkScript []byte

+ OutPoint wire.OutPoint

+ func (e *EdgePoint) String() string

+ type FailureReason byte

+ const FailureReasonError

+ const FailureReasonInsufficientBalance

+ const FailureReasonNoRoute

+ const FailureReasonPaymentDetails

+ const FailureReasonTimeout

+ func (r FailureReason) String() string

+ type ForwardingEvent struct

+ AmtIn lnwire.MilliSatoshi

+ AmtOut lnwire.MilliSatoshi

+ 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 *bbolt.Tx, addRefs ...AddRef) error

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

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

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

+ SetFwdFilter func(tx *bbolt.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 *bbolt.Tx, source lnwire.ShortChannelID) ([]*FwdPkg, error)

type HTLC

+ HtlcIndex uint64

+ LogIndex uint64

+ OnionBlob []byte

+ OutputIndex int32

+ Signature []byte

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

+ type HTLCAttempt struct

+ AttemptTime time.Time

+ Failure *HTLCFailInfo

+ PaymentID uint64

+ Route route.Route

+ SessionKey *btcec.PrivateKey

+ Settle *HTLCSettleInfo

+ type HTLCFailInfo struct

+ FailTime time.Time

+ type HTLCSettleInfo struct

+ Preimage lntypes.Preimage

+ SettleTime time.Time

+ type HtlcAcceptDesc struct

+ AcceptHeight int32

+ Amt lnwire.MilliSatoshi

+ CustomRecords record.CustomSet

+ Expiry uint32

+ MppTotalAmt lnwire.MilliSatoshi

+ type HtlcState uint8

+ const HtlcStateAccepted

+ const HtlcStateCanceled

+ const HtlcStateSettled

+ type InFlightPayment struct

+ Attempt *PaymentAttemptInfo

+ Info *PaymentCreationInfo

type Invoice

+ AddIndex uint64

+ AmtPaid lnwire.MilliSatoshi

+ Htlcs map[CircuitKey]*InvoiceHTLC

+ PaymentRequest []byte

+ SettleDate time.Time

+ SettleIndex uint64

+ State ContractState

+ func (i *Invoice) IsPending() bool

+ type InvoiceHTLC struct

+ AcceptHeight uint32

+ AcceptTime time.Time

+ Amt lnwire.MilliSatoshi

+ CustomRecords record.CustomSet

+ Expiry uint32

+ MppTotalAmt lnwire.MilliSatoshi

+ ResolveTime time.Time

+ State HtlcState

+ type InvoiceQuery struct

+ IndexOffset uint64

+ NumMaxInvoices uint64

+ PendingOnly bool

+ Reversed bool

+ type InvoiceSlice struct

+ FirstIndexOffset uint64

+ Invoices []Invoice

+ LastIndexOffset uint64

+ type InvoiceStateUpdateDesc struct

+ NewState ContractState

+ Preimage lntypes.Preimage

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

+ type InvoiceUpdateDesc struct

+ AddHtlcs map[CircuitKey]*HtlcAcceptDesc

+ CancelHtlcs map[CircuitKey]struct{}

+ State *InvoiceStateUpdateDesc

+ type InvoiceWithPaymentHash struct

+ Invoice Invoice

+ PaymentHash lntypes.Hash

+ 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 *btcec.PublicKey)

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

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

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

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

+ type LinkNode struct

+ Addresses []net.Addr

+ IdentityPub *btcec.PublicKey

+ LastSeen time.Time

+ Network wire.BitcoinNet

+ 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 MPPayment struct

+ FailureReason *FailureReason

+ HTLCs []HTLCAttempt

+ Info *MPPaymentCreationInfo

+ Status PaymentStatus

+ type MPPaymentCreationInfo struct

+ CreationTime time.Time

+ PaymentHash lntypes.Hash

+ PaymentRequest []byte

+ Value lnwire.MilliSatoshi

+ type Meta struct

+ DbVersionNumber uint32

type OpenChannel

+ ChainHash chainhash.Hash

+ ChanType ChannelType

+ ChannelFlags lnwire.FundingFlag

+ FundingBroadcastHeight uint32

+ FundingTxn *wire.MsgTx

+ IdentityPub *btcec.PublicKey

+ IsInitiator bool

+ IsPending bool

+ LocalChanCfg ChannelConfig

+ LocalCommitment ChannelCommitment

+ LocalShutdownScript lnwire.DeliveryAddress

+ NumConfsRequired uint16

+ Packager FwdPackager

+ RemoteChanCfg ChannelConfig

+ RemoteCommitment ChannelCommitment

+ RemoteCurrentRevocation *btcec.PublicKey

+ RemoteNextRevocation *btcec.PublicKey

+ RemoteShutdownScript lnwire.DeliveryAddress

+ RevocationProducer shachain.Producer

+ RevocationStore shachain.Store

+ ShortChannelID lnwire.ShortChannelID

+ TotalMSatReceived lnwire.MilliSatoshi

+ TotalMSatSent lnwire.MilliSatoshi

+ 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) ApplyChanStatus(status ChannelStatus) error

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

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

+ func (c *OpenChannel) ChanStatus() ChannelStatus

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

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

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

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

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

+ func (c *OpenChannel) InsertNextRevocation(revKey *btcec.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(closeTx *wire.MsgTx, locallyInitiated bool) error

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

+ func (c *OpenChannel) MarkDataLoss(commitPoint *btcec.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) SyncPending(addr net.Addr, pendingHeight uint32) error

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

+ type OptionModifier func(*Options)

+ func OptionClock(clock clock.Clock) OptionModifier

+ 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

+ Preimage *lntypes.Preimage

+ Status PaymentStatus

+ func (p *Payment) ToMPPayment() *MPPayment

+ type PaymentAttemptInfo struct

+ PaymentID uint64

+ Route route.Route

+ SessionKey *btcec.PrivateKey

+ type PaymentControl struct

+ func NewPaymentControl(db *DB) *PaymentControl

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

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

+ func (p *PaymentControl) FetchPayment(paymentHash lntypes.Hash) (*MPPayment, 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) (*MPPayment, error)

+ type PaymentCreationInfo struct

+ CreationDate time.Time

+ PaymentHash lntypes.Hash

+ PaymentRequest []byte

+ Value lnwire.MilliSatoshi

+ type PaymentStatus byte

+ const StatusFailed

+ const StatusInFlight

+ const StatusSucceeded

+ const StatusUnknown

+ 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 *bbolt.Tx, settleFailRefs ...SettleFailRef) error

+ type SettleFailRef struct

+ Height uint64

+ Index uint16

+ Source lnwire.ShortChannelID

+ type SwitchPackager struct

+ func NewSwitchPackager() *SwitchPackager

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

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

+ type UnknownElementType struct

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

+ 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) AddSha256Witnesses(preimages ...lntypes.Preimage) error

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

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

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

+ type WitnessType uint8

+ var Sha256HashWitness WitnessType = 1

v0.4.2-beta

May 29, 2018

v0.4.1-beta

Apr 3, 2018

v0.2.1-alpha

Apr 13, 2017

v0.1.1-alpha

Jan 18, 2017

v0.0.2

Oct 3, 2016

Changes in this version

+ const MaxMemoSize

+ const MaxReceiptSize

+ var ErrChannelNoExist = fmt.Errorf("this channel does not exist")

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

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

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

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

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

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

+ func DisableLog()

+ func SetLogWriter(w io.Writer, level string) error

+ func UseLogger(logger btclog.Logger)

+ type ChannelDelta struct

+ Htlcs []*HTLC

+ LocalBalance btcutil.Amount

+ RemoteBalance btcutil.Amount

+ UpdateNum uint32

+ type ChannelSnapshot struct

+ Capacity btcutil.Amount

+ ChannelPoint *wire.OutPoint

+ Htlcs []HTLC

+ LocalBalance btcutil.Amount

+ NumUpdates uint64

+ RemoteBalance btcutil.Amount

+ RemoteID [wire.HashSize]byte

+ TotalSatoshisReceived uint64

+ TotalSatoshisSent uint64

+ type ContractTerm struct

+ PaymentPreimage [32]byte

+ Settled bool

+ Value btcutil.Amount

+ type DB struct

+ func Open(dbPath string, netParams *chaincfg.Params) (*DB, error)

+ func (d *DB) AddInvoice(i *Invoice) error

+ func (d *DB) Close() error

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

+ func (d *DB) FetchOpenChannels(nodeID *wire.ShaHash) ([]*OpenChannel, error)

+ func (d *DB) GetIdAdr() (*btcutil.AddressPubKeyHash, error)

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

+ func (d *DB) PutIdKey(pkh []byte) error

+ func (d *DB) SettleInvoice(paymentHash [32]byte) error

+ func (d *DB) Wipe() error

+ type HTLC struct

+ Amt btcutil.Amount

+ Incoming bool

+ RHash [32]byte

+ RefundTimeout uint32

+ RevocationDelay uint32

+ func (h *HTLC) Copy() HTLC

+ type Invoice struct

+ CreationDate time.Time

+ Memo []byte

+ Receipt []byte

+ Terms ContractTerm

+ type OpenChannel struct

+ Capacity btcutil.Amount

+ ChanID *wire.OutPoint

+ CreationTime time.Time

+ Db *DB

+ FundingOutpoint *wire.OutPoint

+ FundingRedeemScript []byte

+ Htlcs []*HTLC

+ LocalCsvDelay uint32

+ LocalElkrem *elkrem.ElkremSender

+ MinFeePerKb btcutil.Amount

+ NumUpdates uint64

+ OurBalance btcutil.Amount

+ OurCommitKey *btcec.PublicKey

+ OurCommitSig []byte

+ OurCommitTx *wire.MsgTx

+ OurDeliveryScript []byte

+ OurMultiSigKey *btcec.PublicKey

+ RemoteCsvDelay uint32

+ RemoteElkrem *elkrem.ElkremReceiver

+ TheirBalance btcutil.Amount

+ TheirCommitKey *btcec.PublicKey

+ TheirCurrentRevocation *btcec.PublicKey

+ TheirCurrentRevocationHash [32]byte

+ TheirDeliveryScript []byte

+ TheirLNID [wire.HashSize]byte

+ TheirMultiSigKey *btcec.PublicKey

+ TotalNetFees uint64

+ TotalSatoshisReceived uint64

+ TotalSatoshisSent uint64

+ func (c *OpenChannel) AppendToRevocationLog(delta *ChannelDelta) error

+ func (c *OpenChannel) CloseChannel() error

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

+ func (c *OpenChannel) FullSync() error

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

+ func (c *OpenChannel) UpdateCommitment(newCommitment *wire.MsgTx, newSig []byte, delta *ChannelDelta) error

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