htlcswitch/mock: update mock obfuscator and iterators w/ new sphinx API

This commit is contained in:
Conner Fromknecht 2018-02-23 17:18:25 -08:00
parent 27df8d8ad1
commit 06fb524a3b
No known key found for this signature in database
GPG Key ID: 39DE78FBE6ACB0EF

@ -15,6 +15,7 @@ import (
"github.com/btcsuite/fastsha256" "github.com/btcsuite/fastsha256"
"github.com/go-errors/errors" "github.com/go-errors/errors"
"github.com/lightningnetwork/lightning-onion"
"github.com/lightningnetwork/lnd/chainntnfs" "github.com/lightningnetwork/lnd/chainntnfs"
"github.com/lightningnetwork/lnd/channeldb" "github.com/lightningnetwork/lnd/channeldb"
"github.com/lightningnetwork/lnd/contractcourt" "github.com/lightningnetwork/lnd/contractcourt"
@ -195,6 +196,10 @@ type mockHopIterator struct {
hops []ForwardingInfo hops []ForwardingInfo
} }
func (r *mockHopIterator) OnionPacket() *sphinx.OnionPacket {
return nil
}
func newMockHopIterator(hops ...ForwardingInfo) HopIterator { func newMockHopIterator(hops ...ForwardingInfo) HopIterator {
return &mockHopIterator{hops: hops} return &mockHopIterator{hops: hops}
} }
@ -205,6 +210,12 @@ func (r *mockHopIterator) ForwardingInstructions() ForwardingInfo {
return h return h
} }
func (r *mockHopIterator) ExtractErrorEncrypter(
extracter ErrorEncrypterExtracter) (ErrorEncrypter, lnwire.FailCode) {
return extracter(nil)
}
func (r *mockHopIterator) EncodeNextHop(w io.Writer) error { func (r *mockHopIterator) EncodeNextHop(w io.Writer) error {
var hopLength [4]byte var hopLength [4]byte
binary.BigEndian.PutUint32(hopLength[:], uint32(len(r.hops))) binary.BigEndian.PutUint32(hopLength[:], uint32(len(r.hops)))
@ -246,12 +257,30 @@ var _ HopIterator = (*mockHopIterator)(nil)
// mockObfuscator mock implementation of the failure obfuscator which only // mockObfuscator mock implementation of the failure obfuscator which only
// encodes the failure and do not makes any onion obfuscation. // encodes the failure and do not makes any onion obfuscation.
type mockObfuscator struct{} type mockObfuscator struct {
ogPacket *sphinx.OnionPacket
}
func newMockObfuscator() ErrorEncrypter { func newMockObfuscator() ErrorEncrypter {
return &mockObfuscator{} return &mockObfuscator{}
} }
func (o *mockObfuscator) OnionPacket() *sphinx.OnionPacket {
return o.ogPacket
}
func (o *mockObfuscator) Type() EncrypterType {
return EncrypterTypeMock
}
func (o *mockObfuscator) Encode(w io.Writer) error {
return nil
}
func (o *mockObfuscator) Decode(r io.Reader) error {
return nil
}
func (o *mockObfuscator) EncryptFirstHop(failure lnwire.FailureMessage) ( func (o *mockObfuscator) EncryptFirstHop(failure lnwire.FailureMessage) (
lnwire.OpaqueReason, error) { lnwire.OpaqueReason, error) {
@ -292,10 +321,20 @@ var _ ErrorDecrypter = (*mockDeobfuscator)(nil)
// mockIteratorDecoder test version of hop iterator decoder which decodes the // mockIteratorDecoder test version of hop iterator decoder which decodes the
// encoded array of hops. // encoded array of hops.
type mockIteratorDecoder struct{} type mockIteratorDecoder struct {
mu sync.RWMutex
func (p *mockIteratorDecoder) DecodeHopIterator(r io.Reader, meta []byte) ( responses map[[32]byte][]DecodeHopIteratorResponse
HopIterator, lnwire.FailCode) { }
func newMockIteratorDecoder() *mockIteratorDecoder {
return &mockIteratorDecoder{
responses: make(map[[32]byte][]DecodeHopIteratorResponse),
}
}
func (p *mockIteratorDecoder) DecodeHopIterator(r io.Reader, rHash []byte,
cltv uint32) (HopIterator, lnwire.FailCode) {
var b [4]byte var b [4]byte
_, err := r.Read(b[:]) _, err := r.Read(b[:])
@ -317,6 +356,40 @@ func (p *mockIteratorDecoder) DecodeHopIterator(r io.Reader, meta []byte) (
return newMockHopIterator(hops...), lnwire.CodeNone return newMockHopIterator(hops...), lnwire.CodeNone
} }
func (p *mockIteratorDecoder) DecodeHopIterators(id []byte,
reqs []DecodeHopIteratorRequest) ([]DecodeHopIteratorResponse, error) {
idHash := sha256.Sum256(id)
p.mu.RLock()
if resps, ok := p.responses[idHash]; ok {
p.mu.RUnlock()
return resps, nil
}
p.mu.RUnlock()
batchSize := len(reqs)
resps := make([]DecodeHopIteratorResponse, 0, batchSize)
for _, req := range reqs {
iterator, failcode := p.DecodeHopIterator(
req.OnionReader, req.RHash, req.IncomingCltv,
)
resp := DecodeHopIteratorResponse{
HopIterator: iterator,
FailCode: failcode,
}
resps = append(resps, resp)
}
p.mu.Lock()
p.responses[idHash] = resps
p.mu.Unlock()
return resps, nil
}
func (f *ForwardingInfo) decode(r io.Reader) error { func (f *ForwardingInfo) decode(r io.Reader) error {
var net [1]byte var net [1]byte
if _, err := r.Read(net[:]); err != nil { if _, err := r.Read(net[:]); err != nil {