package channeldb import ( "fmt" "github.com/lightningnetwork/lnd/kvdb" "github.com/lightningnetwork/lnd/lntypes" ) var ( // ErrNoWitnesses is an error that's returned when no new witnesses have // been added to the WitnessCache. ErrNoWitnesses = fmt.Errorf("no witnesses") // ErrUnknownWitnessType is returned if a caller attempts to ErrUnknownWitnessType = fmt.Errorf("unknown witness type") ) // WitnessType is enum that denotes what "type" of witness is being // stored/retrieved. As the WitnessCache itself is agnostic and doesn't enforce // any structure on added witnesses, we use this type to partition the // witnesses on disk, and also to know how to map a witness to its look up key. type WitnessType uint8 var ( // Sha256HashWitness is a witness that is simply the pre image to a // hash image. In order to map to its key, we'll use sha256. Sha256HashWitness WitnessType = 1 ) // toDBKey is a helper method that maps a witness type to the key that we'll // use to store it within the database. func (w WitnessType) toDBKey() ([]byte, error) { switch w { case Sha256HashWitness: return []byte{byte(w)}, nil default: return nil, ErrUnknownWitnessType } } var ( // witnessBucketKey is the name of the bucket that we use to store all // witnesses encountered. Within this bucket, we'll create a sub-bucket for // each witness type. witnessBucketKey = []byte("byte") ) // WitnessCache is a persistent cache of all witnesses we've encountered on the // network. In the case of multi-hop, multi-step contracts, a cache of all // witnesses can be useful in the case of partial contract resolution. If // negotiations break down, we may be forced to locate the witness for a // portion of the contract on-chain. In this case, we'll then add that witness // to the cache so the incoming contract can fully resolve witness. // Additionally, as one MUST always use a unique witness on the network, we may // use this cache to detect duplicate witnesses. // // TODO(roasbeef): need expiry policy? // * encrypt? type WitnessCache struct { db *DB } // NewWitnessCache returns a new instance of the witness cache. func (d *DB) NewWitnessCache() *WitnessCache { return &WitnessCache{ db: d, } } // witnessEntry is a key-value struct that holds each key -> witness pair, used // when inserting records into the cache. type witnessEntry struct { key []byte witness []byte } // AddSha256Witnesses adds a batch of new sha256 preimages into the witness // cache. This is an alias for AddWitnesses that uses Sha256HashWitness as the // preimages' witness type. func (w *WitnessCache) AddSha256Witnesses(preimages ...lntypes.Preimage) error { // Optimistically compute the preimages' hashes before attempting to // start the db transaction. entries := make([]witnessEntry, 0, len(preimages)) for i := range preimages { hash := preimages[i].Hash() entries = append(entries, witnessEntry{ key: hash[:], witness: preimages[i][:], }) } return w.addWitnessEntries(Sha256HashWitness, entries) } // addWitnessEntries inserts the witnessEntry key-value pairs into the cache, // using the appropriate witness type to segment the namespace of possible // witness types. func (w *WitnessCache) addWitnessEntries(wType WitnessType, entries []witnessEntry) error { // Exit early if there are no witnesses to add. if len(entries) == 0 { return nil } return kvdb.Batch(w.db.Backend, func(tx kvdb.RwTx) error { witnessBucket, err := tx.CreateTopLevelBucket(witnessBucketKey) if err != nil { return err } witnessTypeBucketKey, err := wType.toDBKey() if err != nil { return err } witnessTypeBucket, err := witnessBucket.CreateBucketIfNotExists( witnessTypeBucketKey, ) if err != nil { return err } for _, entry := range entries { err = witnessTypeBucket.Put(entry.key, entry.witness) if err != nil { return err } } return nil }) } // LookupSha256Witness attempts to lookup the preimage for a sha256 hash. If // the witness isn't found, ErrNoWitnesses will be returned. func (w *WitnessCache) LookupSha256Witness(hash lntypes.Hash) (lntypes.Preimage, error) { witness, err := w.lookupWitness(Sha256HashWitness, hash[:]) if err != nil { return lntypes.Preimage{}, err } return lntypes.MakePreimage(witness) } // lookupWitness attempts to lookup a witness according to its type and also // its witness key. In the case that the witness isn't found, ErrNoWitnesses // will be returned. func (w *WitnessCache) lookupWitness(wType WitnessType, witnessKey []byte) ([]byte, error) { var witness []byte err := kvdb.View(w.db, func(tx kvdb.RTx) error { witnessBucket := tx.ReadBucket(witnessBucketKey) if witnessBucket == nil { return ErrNoWitnesses } witnessTypeBucketKey, err := wType.toDBKey() if err != nil { return err } witnessTypeBucket := witnessBucket.NestedReadBucket(witnessTypeBucketKey) if witnessTypeBucket == nil { return ErrNoWitnesses } dbWitness := witnessTypeBucket.Get(witnessKey) if dbWitness == nil { return ErrNoWitnesses } witness = make([]byte, len(dbWitness)) copy(witness[:], dbWitness) return nil }, func() { witness = nil }) if err != nil { return nil, err } return witness, nil } // DeleteSha256Witness attempts to delete a sha256 preimage identified by hash. func (w *WitnessCache) DeleteSha256Witness(hash lntypes.Hash) error { return w.deleteWitness(Sha256HashWitness, hash[:]) } // deleteWitness attempts to delete a particular witness from the database. func (w *WitnessCache) deleteWitness(wType WitnessType, witnessKey []byte) error { return kvdb.Batch(w.db.Backend, func(tx kvdb.RwTx) error { witnessBucket, err := tx.CreateTopLevelBucket(witnessBucketKey) if err != nil { return err } witnessTypeBucketKey, err := wType.toDBKey() if err != nil { return err } witnessTypeBucket, err := witnessBucket.CreateBucketIfNotExists( witnessTypeBucketKey, ) if err != nil { return err } return witnessTypeBucket.Delete(witnessKey) }) } // DeleteWitnessClass attempts to delete an *entire* class of witnesses. After // this function return with a non-nil error, func (w *WitnessCache) DeleteWitnessClass(wType WitnessType) error { return kvdb.Batch(w.db.Backend, func(tx kvdb.RwTx) error { witnessBucket, err := tx.CreateTopLevelBucket(witnessBucketKey) if err != nil { return err } witnessTypeBucketKey, err := wType.toDBKey() if err != nil { return err } return witnessBucket.DeleteNestedBucket(witnessTypeBucketKey) }) }