order: generate mocks for order/interfaces.go

The `mockgen` tool seems to have a bug and it is not able to parse a
valid go file. I had to change the `[sha256.Size]byte` to `[size]byte`
and define `hashSize` in the order package in the same way it is defined in
the sha256 one.

gen.go

@@ -8,3 +8,4 @@ package pool
 //go:generate mockgen -source=sidecar/interfaces.go -package=sidecar -destination=sidecar/mock_interfaces.go
 //go:generate mockgen -source=internal/test/interfaces.go -package=test -destination=internal/test/mock_interfaces.go
 //go:generate mockgen -source=account/watcher/interfaces.go -package=watcher -destination=account/watcher/mock_interface_test.go
+//go:generate mockgen -source=order/interfaces.go -package=order -destination=order/mock_interfaces.go

order/interfaces.go

@@ -23,6 +23,13 @@ import (
 // Nonce is a 32 byte pseudo randomly generated unique order ID.
 type Nonce [32]byte
 
+// The size of a SHA256 checksum in bytes.
+//
+// Note: this matches the sha256.Size definition. However, mockgen
+// complains about not being able to find the sha256 package. When
+// that bug is fixed, we can change back to [sha256.Size]byte.
+const hashSize = 32
+
 // String returns the hex encoded representation of the nonce.
 func (n Nonce) String() string {
 	return hex.EncodeToString(n[:])
@@ -266,7 +273,7 @@ type Order interface {
 	// Digest returns a deterministic SHA256 hash over the contents of an
 	// order. Deterministic in this context means that if two orders have
 	// the same content, their digest have to be identical as well.
-	Digest() ([sha256.Size]byte, error)
+	Digest() ([hashSize]byte, error)
 
 	// ReservedValue returns the maximum value that could be deducted from
 	// the account if the order is is matched, and therefore has to be
@@ -392,10 +399,10 @@ func (a *Ask) Type() Type {
 // their digest have to be identical as well.
 //
 // NOTE: This method is part of the Order interface.
-func (a *Ask) Digest() ([sha256.Size]byte, error) {
+func (a *Ask) Digest() ([hashSize]byte, error) {
 	var (
 		msg    bytes.Buffer
-		result [sha256.Size]byte
+		result [hashSize]byte
 	)
 	switch a.Kit.Version {
 	case VersionDefault:
@@ -591,10 +598,10 @@ func (b *Bid) Type() Type {
 // their digest have to be identical as well.
 //
 // NOTE: This method is part of the Order interface.
-func (b *Bid) Digest() ([sha256.Size]byte, error) {
+func (b *Bid) Digest() ([hashSize]byte, error) {
 	var (
 		msg    bytes.Buffer
-		result [sha256.Size]byte
+		result [hashSize]byte
 	)
 	switch b.Kit.Version {
 	case VersionDefault:

order/mock_interfaces.go

@@ -0,0 +1,387 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: order/interfaces.go
+
+// Package order is a generated GoMock package.
+package order
+
+import (
+	context "context"
+	reflect "reflect"
+
+	btcutil "github.com/btcsuite/btcutil"
+	gomock "github.com/golang/mock/gomock"
+	account "github.com/lightninglabs/pool/account"
+	terms "github.com/lightninglabs/pool/terms"
+)
+
+// MockOrder is a mock of Order interface.
+type MockOrder struct {
+	ctrl     *gomock.Controller
+	recorder *MockOrderMockRecorder
+}
+
+// MockOrderMockRecorder is the mock recorder for MockOrder.
+type MockOrderMockRecorder struct {
+	mock *MockOrder
+}
+
+// NewMockOrder creates a new mock instance.
+func NewMockOrder(ctrl *gomock.Controller) *MockOrder {
+	mock := &MockOrder{ctrl: ctrl}
+	mock.recorder = &MockOrderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockOrder) EXPECT() *MockOrderMockRecorder {
+	return m.recorder
+}
+
+// Details mocks base method.
+func (m *MockOrder) Details() *Kit {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Details")
+	ret0, _ := ret[0].(*Kit)
+	return ret0
+}
+
+// Details indicates an expected call of Details.
+func (mr *MockOrderMockRecorder) Details() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Details", reflect.TypeOf((*MockOrder)(nil).Details))
+}
+
+// Digest mocks base method.
+func (m *MockOrder) Digest() ([32]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Digest")
+	ret0, _ := ret[0].([32]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Digest indicates an expected call of Digest.
+func (mr *MockOrderMockRecorder) Digest() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Digest", reflect.TypeOf((*MockOrder)(nil).Digest))
+}
+
+// Nonce mocks base method.
+func (m *MockOrder) Nonce() Nonce {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Nonce")
+	ret0, _ := ret[0].(Nonce)
+	return ret0
+}
+
+// Nonce indicates an expected call of Nonce.
+func (mr *MockOrderMockRecorder) Nonce() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nonce", reflect.TypeOf((*MockOrder)(nil).Nonce))
+}
+
+// ReservedValue mocks base method.
+func (m *MockOrder) ReservedValue(feeSchedule terms.FeeSchedule) btcutil.Amount {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReservedValue", feeSchedule)
+	ret0, _ := ret[0].(btcutil.Amount)
+	return ret0
+}
+
+// ReservedValue indicates an expected call of ReservedValue.
+func (mr *MockOrderMockRecorder) ReservedValue(feeSchedule interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReservedValue", reflect.TypeOf((*MockOrder)(nil).ReservedValue), feeSchedule)
+}
+
+// Type mocks base method.
+func (m *MockOrder) Type() Type {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Type")
+	ret0, _ := ret[0].(Type)
+	return ret0
+}
+
+// Type indicates an expected call of Type.
+func (mr *MockOrderMockRecorder) Type() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockOrder)(nil).Type))
+}
+
+// MockStore is a mock of Store interface.
+type MockStore struct {
+	ctrl     *gomock.Controller
+	recorder *MockStoreMockRecorder
+}
+
+// MockStoreMockRecorder is the mock recorder for MockStore.
+type MockStoreMockRecorder struct {
+	mock *MockStore
+}
+
+// NewMockStore creates a new mock instance.
+func NewMockStore(ctrl *gomock.Controller) *MockStore {
+	mock := &MockStore{ctrl: ctrl}
+	mock.recorder = &MockStoreMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStore) EXPECT() *MockStoreMockRecorder {
+	return m.recorder
+}
+
+// GetOrder mocks base method.
+func (m *MockStore) GetOrder(arg0 Nonce) (Order, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOrder", arg0)
+	ret0, _ := ret[0].(Order)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrder indicates an expected call of GetOrder.
+func (mr *MockStoreMockRecorder) GetOrder(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrder", reflect.TypeOf((*MockStore)(nil).GetOrder), arg0)
+}
+
+// GetOrders mocks base method.
+func (m *MockStore) GetOrders() ([]Order, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOrders")
+	ret0, _ := ret[0].([]Order)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrders indicates an expected call of GetOrders.
+func (mr *MockStoreMockRecorder) GetOrders() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrders", reflect.TypeOf((*MockStore)(nil).GetOrders))
+}
+
+// MarkBatchComplete mocks base method.
+func (m *MockStore) MarkBatchComplete() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MarkBatchComplete")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// MarkBatchComplete indicates an expected call of MarkBatchComplete.
+func (mr *MockStoreMockRecorder) MarkBatchComplete() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkBatchComplete", reflect.TypeOf((*MockStore)(nil).MarkBatchComplete))
+}
+
+// StorePendingBatch mocks base method.
+func (m *MockStore) StorePendingBatch(arg0 *Batch, orders []Nonce, orderModifiers [][]Modifier, accounts []*account.Account, accountModifiers [][]account.Modifier) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StorePendingBatch", arg0, orders, orderModifiers, accounts, accountModifiers)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// StorePendingBatch indicates an expected call of StorePendingBatch.
+func (mr *MockStoreMockRecorder) StorePendingBatch(arg0, orders, orderModifiers, accounts, accountModifiers interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorePendingBatch", reflect.TypeOf((*MockStore)(nil).StorePendingBatch), arg0, orders, orderModifiers, accounts, accountModifiers)
+}
+
+// SubmitOrder mocks base method.
+func (m *MockStore) SubmitOrder(arg0 Order) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubmitOrder", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SubmitOrder indicates an expected call of SubmitOrder.
+func (mr *MockStoreMockRecorder) SubmitOrder(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitOrder", reflect.TypeOf((*MockStore)(nil).SubmitOrder), arg0)
+}
+
+// UpdateOrder mocks base method.
+func (m *MockStore) UpdateOrder(arg0 Nonce, arg1 ...Modifier) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0}
+	for _, a := range arg1 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateOrder", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateOrder indicates an expected call of UpdateOrder.
+func (mr *MockStoreMockRecorder) UpdateOrder(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrder", reflect.TypeOf((*MockStore)(nil).UpdateOrder), varargs...)
+}
+
+// UpdateOrders mocks base method.
+func (m *MockStore) UpdateOrders(arg0 []Nonce, arg1 [][]Modifier) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateOrders", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateOrders indicates an expected call of UpdateOrders.
+func (mr *MockStoreMockRecorder) UpdateOrders(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrders", reflect.TypeOf((*MockStore)(nil).UpdateOrders), arg0, arg1)
+}
+
+// MockManager is a mock of Manager interface.
+type MockManager struct {
+	ctrl     *gomock.Controller
+	recorder *MockManagerMockRecorder
+}
+
+// MockManagerMockRecorder is the mock recorder for MockManager.
+type MockManagerMockRecorder struct {
+	mock *MockManager
+}
+
+// NewMockManager creates a new mock instance.
+func NewMockManager(ctrl *gomock.Controller) *MockManager {
+	mock := &MockManager{ctrl: ctrl}
+	mock.recorder = &MockManagerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockManager) EXPECT() *MockManagerMockRecorder {
+	return m.recorder
+}
+
+// BatchFinalize mocks base method.
+func (m *MockManager) BatchFinalize(batchID BatchID) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchFinalize", batchID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BatchFinalize indicates an expected call of BatchFinalize.
+func (mr *MockManagerMockRecorder) BatchFinalize(batchID interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchFinalize", reflect.TypeOf((*MockManager)(nil).BatchFinalize), batchID)
+}
+
+// BatchSign mocks base method.
+func (m *MockManager) BatchSign() (BatchSignature, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchSign")
+	ret0, _ := ret[0].(BatchSignature)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BatchSign indicates an expected call of BatchSign.
+func (mr *MockManagerMockRecorder) BatchSign() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchSign", reflect.TypeOf((*MockManager)(nil).BatchSign))
+}
+
+// HasPendingBatch mocks base method.
+func (m *MockManager) HasPendingBatch() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HasPendingBatch")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// HasPendingBatch indicates an expected call of HasPendingBatch.
+func (mr *MockManagerMockRecorder) HasPendingBatch() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPendingBatch", reflect.TypeOf((*MockManager)(nil).HasPendingBatch))
+}
+
+// OrderMatchValidate mocks base method.
+func (m *MockManager) OrderMatchValidate(batch *Batch, bestHeight uint32) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrderMatchValidate", batch, bestHeight)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OrderMatchValidate indicates an expected call of OrderMatchValidate.
+func (mr *MockManagerMockRecorder) OrderMatchValidate(batch, bestHeight interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderMatchValidate", reflect.TypeOf((*MockManager)(nil).OrderMatchValidate), batch, bestHeight)
+}
+
+// OurNodePubkey mocks base method.
+func (m *MockManager) OurNodePubkey() ([33]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OurNodePubkey")
+	ret0, _ := ret[0].([33]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OurNodePubkey indicates an expected call of OurNodePubkey.
+func (mr *MockManagerMockRecorder) OurNodePubkey() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OurNodePubkey", reflect.TypeOf((*MockManager)(nil).OurNodePubkey))
+}
+
+// PendingBatch mocks base method.
+func (m *MockManager) PendingBatch() *Batch {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PendingBatch")
+	ret0, _ := ret[0].(*Batch)
+	return ret0
+}
+
+// PendingBatch indicates an expected call of PendingBatch.
+func (mr *MockManagerMockRecorder) PendingBatch() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingBatch", reflect.TypeOf((*MockManager)(nil).PendingBatch))
+}
+
+// PrepareOrder mocks base method.
+func (m *MockManager) PrepareOrder(ctx context.Context, order Order, acct *account.Account, terms *terms.AuctioneerTerms) (*ServerOrderParams, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrepareOrder", ctx, order, acct, terms)
+	ret0, _ := ret[0].(*ServerOrderParams)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrepareOrder indicates an expected call of PrepareOrder.
+func (mr *MockManagerMockRecorder) PrepareOrder(ctx, order, acct, terms interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareOrder", reflect.TypeOf((*MockManager)(nil).PrepareOrder), ctx, order, acct, terms)
+}
+
+// Start mocks base method.
+func (m *MockManager) Start() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Start")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Start indicates an expected call of Start.
+func (mr *MockManagerMockRecorder) Start() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start))
+}
+
+// Stop mocks base method.
+func (m *MockManager) Stop() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Stop")
+}
+
+// Stop indicates an expected call of Stop.
+func (mr *MockManagerMockRecorder) Stop() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockManager)(nil).Stop))
+}