GlcoinCore/alby-hub
1
0
Fork 0
mirror of https://github.com/getAlby/hub.git synced 2026-08-13 12:33:39 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

chore: change param from isHoldInvoice to timeoutSeconds

Browse source
This commit is contained in:
im-adithya 2025-05-09 17:47:45 +05:30
parent c47810b7e6
commit 54e8616a3f
15 changed files with 66 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

4
api/transactions.go
View file

@ -65,7 +65,7 @@ func (api *api) SendPayment(ctx context.Context, invoice string, amountMsat *uin
if api.svc.GetLNClient() == nil {
return nil, errors.New("LNClient not started")
}
transaction, err := api.svc.GetTransactionsService().SendPaymentSync(ctx, invoice, amountMsat, nil, api.svc.GetLNClient(), nil, nil, false)
transaction, err := api.svc.GetTransactionsService().SendPaymentSync(ctx, invoice, amountMsat, nil, api.svc.GetLNClient(), nil, nil, 50)
if err != nil {
return nil, err
}
@ -142,7 +142,7 @@ func (api *api) TopupIsolatedApp(ctx context.Context, userApp *db.App, amountMsa
return err
}
_, err = api.svc.GetTransactionsService().SendPaymentSync(ctx, transaction.PaymentRequest, nil, nil, api.svc.GetLNClient(), nil, nil, false)
_, err = api.svc.GetTransactionsService().SendPaymentSync(ctx, transaction.PaymentRequest, nil, nil, api.svc.GetLNClient(), nil, nil, 50)
return err
}

2
lnclient/cashu/cashu.go
View file

@ -72,7 +72,7 @@ func (cs *CashuService) Shutdown() error {
return cs.wallet.Shutdown()
}
func (cs *CashuService) SendPaymentSync(ctx context.Context, invoice string, amount *uint64, isHoldInvoice bool) (response *lnclient.PayInvoiceResponse, err error) {
func (cs *CashuService) SendPaymentSync(ctx context.Context, invoice string, amount *uint64, timeoutSeconds int64) (response *lnclient.PayInvoiceResponse, err error) {
// TODO: support 0-amount invoices
if amount != nil {
return nil, errors.New("0-amount invoices not supported")

7
lnclient/ldk/ldk.go
View file

@ -435,7 +435,7 @@ func getMaxTotalRoutingFeeLimit(amountMsat uint64) ldk_node.MaxTotalRoutingFeeLi
}
}
func (ls *LDKService) SendPaymentSync(ctx context.Context, invoice string, amount *uint64, isHoldInvoice bool) (*lnclient.PayInvoiceResponse, error) {
func (ls *LDKService) SendPaymentSync(ctx context.Context, invoice string, amount *uint64, timeoutSeconds int64) (*lnclient.PayInvoiceResponse, error) {
paymentRequest, err := decodepay.Decodepay(invoice)
if err != nil {
logger.Logger.WithFields(logrus.Fields{
@ -484,10 +484,7 @@ func (ls *LDKService) SendPaymentSync(ctx context.Context, invoice string, amoun
}
fee := uint64(0)
preimage := ""
timeout := time.Second * 50
if isHoldInvoice {
timeout = time.Hour * 1
}
timeout := time.Second * time.Duration(timeoutSeconds)
for start := time.Now(); time.Since(start) < timeout; {
event := <-ldkEventSubscription

9
lnclient/lnd/lnd.go
View file

@ -284,14 +284,9 @@ func (svc *LNDService) Shutdown() error {
return nil
}
func (svc *LNDService) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, isHoldInvoice bool) (*lnclient.PayInvoiceResponse, error) {
func (svc *LNDService) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, timeoutSeconds int64) (*lnclient.PayInvoiceResponse, error) {
const MAX_PARTIAL_PAYMENTS = 16
sendPaymentTimeout := 50
if isHoldInvoice {
sendPaymentTimeout = 3600
}
paymentRequest, err := decodepay.Decodepay(payReq)
if err != nil {
logger.Logger.WithFields(logrus.Fields{
@ -307,7 +302,7 @@ func (svc *LNDService) SendPaymentSync(ctx context.Context, payReq string, amoun
sendRequest := &routerrpc.SendPaymentRequest{
PaymentRequest: payReq,
MaxParts: MAX_PARTIAL_PAYMENTS,
TimeoutSeconds: int32(sendPaymentTimeout),
TimeoutSeconds: int32(timeoutSeconds),
FeeLimitMsat: int64(transactions.CalculateFeeReserveMsat(paymentAmountMsat)),
}

2
lnclient/models.go
View file

@ -56,7 +56,7 @@ type NodeConnectionInfo struct {
}
type LNClient interface {
SendPaymentSync(ctx context.Context, payReq string, amount *uint64, isHoldInvoice bool) (*PayInvoiceResponse, error)
SendPaymentSync(ctx context.Context, payReq string, amount *uint64, timeoutSeconds int64) (*PayInvoiceResponse, error)
SendKeysend(ctx context.Context, amount uint64, destination string, customRecords []TLVRecord, preimage string) (*PayKeysendResponse, error)
GetPubkey() string
GetInfo(ctx context.Context) (info *NodeInfo, err error)

2
lnclient/phoenixd/phoenixd.go
View file

@ -350,7 +350,7 @@ func (svc *PhoenixService) LookupInvoice(ctx context.Context, paymentHash string
return transaction, nil
}
func (svc *PhoenixService) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, isHoldInvoice bool) (*lnclient.PayInvoiceResponse, error) {
func (svc *PhoenixService) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, timeoutSeconds int64) (*lnclient.PayInvoiceResponse, error) {
// TODO: support 0-amount invoices
if amount != nil {
return nil, errors.New("0-amount invoices not supported")

2
nip47/controllers/pay_invoice_controller.go
View file

@ -59,7 +59,7 @@ func (controller *nip47Controller) pay(ctx context.Context, bolt11 string, amoun
"bolt11": bolt11,
}).Info("Sending payment")
transaction, err := controller.transactionsService.SendPaymentSync(ctx, bolt11, amount, metadata, controller.lnClient, &app.ID, &requestEventId, false)
transaction, err := controller.transactionsService.SendPaymentSync(ctx, bolt11, amount, metadata, controller.lnClient, &app.ID, &requestEventId, 50)
if err != nil {
logger.Logger.WithFields(logrus.Fields{
"request_event_id": requestEventId,

7
swaps/swaps_service.go
View file

@ -244,13 +244,18 @@ func (svc *swapsService) ReverseSwap(ctx context.Context, amount uint64, destina
"swap": swap,
"update": update,
}).Info("Swap created, paying the invoice")
err := lnClient.SendPaymentProbes(ctx, swap.Invoice)
if err != nil {
logger.Logger.WithField("swapId", swap.Id).Info("Couldn't probe invoice payment, terminating swap")
return err
}
go func() {
metadata := map[string]interface{}{
"swapId": swap.Id,
"onchainAmount": swap.OnchainAmount,
"refundPubkey": swap.RefundPublicKey,
}
_, err := svc.transactionsService.SendPaymentSync(ctx, swap.Invoice, nil, metadata, lnClient, nil, nil, false)
_, err := svc.transactionsService.SendPaymentSync(ctx, swap.Invoice, nil, metadata, lnClient, nil, nil, 3600)
if err != nil {
logger.Logger.WithError(err).WithFields(logrus.Fields{
"swap": swap,

2
tests/mock_ln_client.go
View file

@ -78,7 +78,7 @@ func NewMockLn() (*MockLn, error) {
return &MockLn{}, nil
}
func (mln *MockLn) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, isHoldInvoice bool) (*lnclient.PayInvoiceResponse, error) {
func (mln *MockLn) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, timeoutSeconds int64) (*lnclient.PayInvoiceResponse, error) {
if len(mln.PayInvoiceResponses) > 0 {
response := mln.PayInvoiceResponses[0]
err := mln.PayInvoiceErrors[0]

30
tests/mocks/LNClient.go
View file

@ -1572,9 +1572,9 @@ func (_c *MockLNClient_SendPaymentProbes_Call) RunAndReturn(run func(context.Con
return _c
}
// SendPaymentSync provides a mock function with given fields: ctx, payReq, amount, isHoldInvoice
func (_m *MockLNClient) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, isHoldInvoice bool) (*lnclient.PayInvoiceResponse, error) {
ret := _m.Called(ctx, payReq, amount, isHoldInvoice)
// SendPaymentSync provides a mock function with given fields: ctx, payReq, amount, timeoutSeconds
func (_m *MockLNClient) SendPaymentSync(ctx context.Context, payReq string, amount *uint64, timeoutSeconds int64) (*lnclient.PayInvoiceResponse, error) {
ret := _m.Called(ctx, payReq, amount, timeoutSeconds)
if len(ret) == 0 {
panic("no return value specified for SendPaymentSync")
@ -1582,19 +1582,19 @@ func (_m *MockLNClient) SendPaymentSync(ctx context.Context, payReq string, amou
var r0 *lnclient.PayInvoiceResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, *uint64, bool) (*lnclient.PayInvoiceResponse, error)); ok {
return rf(ctx, payReq, amount, isHoldInvoice)
if rf, ok := ret.Get(0).(func(context.Context, string, *uint64, int64) (*lnclient.PayInvoiceResponse, error)); ok {
return rf(ctx, payReq, amount, timeoutSeconds)
}
if rf, ok := ret.Get(0).(func(context.Context, string, *uint64, bool) *lnclient.PayInvoiceResponse); ok {
r0 = rf(ctx, payReq, amount, isHoldInvoice)
if rf, ok := ret.Get(0).(func(context.Context, string, *uint64, int64) *lnclient.PayInvoiceResponse); ok {
r0 = rf(ctx, payReq, amount, timeoutSeconds)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*lnclient.PayInvoiceResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, string, *uint64, bool) error); ok {
r1 = rf(ctx, payReq, amount, isHoldInvoice)
if rf, ok := ret.Get(1).(func(context.Context, string, *uint64, int64) error); ok {
r1 = rf(ctx, payReq, amount, timeoutSeconds)
} else {
r1 = ret.Error(1)
}
@ -1611,14 +1611,14 @@ type MockLNClient_SendPaymentSync_Call struct {
// - ctx context.Context
// - payReq string
// - amount *uint64
// - isHoldInvoice bool
func (_e *MockLNClient_Expecter) SendPaymentSync(ctx interface{}, payReq interface{}, amount interface{}, isHoldInvoice interface{}) *MockLNClient_SendPaymentSync_Call {
return &MockLNClient_SendPaymentSync_Call{Call: _e.mock.On("SendPaymentSync", ctx, payReq, amount, isHoldInvoice)}
// - timeoutSeconds int64
func (_e *MockLNClient_Expecter) SendPaymentSync(ctx interface{}, payReq interface{}, amount interface{}, timeoutSeconds interface{}) *MockLNClient_SendPaymentSync_Call {
return &MockLNClient_SendPaymentSync_Call{Call: _e.mock.On("SendPaymentSync", ctx, payReq, amount, timeoutSeconds)}
}
func (_c *MockLNClient_SendPaymentSync_Call) Run(run func(ctx context.Context, payReq string, amount *uint64, isHoldInvoice bool)) *MockLNClient_SendPaymentSync_Call {
func (_c *MockLNClient_SendPaymentSync_Call) Run(run func(ctx context.Context, payReq string, amount *uint64, timeoutSeconds int64)) *MockLNClient_SendPaymentSync_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(*uint64), args[3].(bool))
run(args[0].(context.Context), args[1].(string), args[2].(*uint64), args[3].(int64))
})
return _c
}
@ -1628,7 +1628,7 @@ func (_c *MockLNClient_SendPaymentSync_Call) Return(_a0 *lnclient.PayInvoiceResp
return _c
}
func (_c *MockLNClient_SendPaymentSync_Call) RunAndReturn(run func(context.Context, string, *uint64, bool) (*lnclient.PayInvoiceResponse, error)) *MockLNClient_SendPaymentSync_Call {
func (_c *MockLNClient_SendPaymentSync_Call) RunAndReturn(run func(context.Context, string, *uint64, int64) (*lnclient.PayInvoiceResponse, error)) *MockLNClient_SendPaymentSync_Call {
_c.Call.Return(run)
return _c
}

12
transactions/app_payments_test.go
View file

@ -28,7 +28,7 @@ func TestSendPaymentSync_App_NoPermission(t *testing.T) {
assert.NoError(t, err)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.Equal(t, "app does not have pay_invoice scope", err.Error())
@ -57,7 +57,7 @@ func TestSendPaymentSync_App_WithPermission(t *testing.T) {
assert.NoError(t, err)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -94,7 +94,7 @@ func TestSendPaymentSync_App_BudgetExceeded(t *testing.T) {
svc.EventPublisher.RegisterSubscriber(mockEventConsumer)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewQuotaExceededError())
@ -141,7 +141,7 @@ func TestSendPaymentSync_App_BudgetExceeded_SettledPayment(t *testing.T) {
assert.NoError(t, err)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewQuotaExceededError())
@ -180,7 +180,7 @@ func TestSendPaymentSync_App_BudgetExceeded_UnsettledPayment(t *testing.T) {
assert.NoError(t, err)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewQuotaExceededError())
@ -220,7 +220,7 @@ func TestSendPaymentSync_App_BudgetNotExceeded_FailedPayment(t *testing.T) {
assert.NoError(t, err)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)

18
transactions/isolated_app_payments_test.go
View file

@ -37,7 +37,7 @@ func TestSendPaymentSync_IsolatedApp_NoBalance(t *testing.T) {
assert.NoError(t, err)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewInsufficientBalanceError())
@ -79,7 +79,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceInsufficient(t *testing.T) {
svc.EventPublisher.RegisterSubscriber(mockEventConsumer)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewInsufficientBalanceError())
@ -125,7 +125,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceSufficient(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -174,7 +174,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceInsufficient_OutstandingPayment(t *t
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewInsufficientBalanceError())
@ -220,7 +220,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceInsufficient_SettledPayment(t *testi
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewInsufficientBalanceError())
@ -265,7 +265,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceSufficient_UnrelatedPayment(t *testi
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -313,7 +313,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceSufficient_FailedPayment(t *testing.
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -355,7 +355,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceInsufficientThenSufficient(t *testin
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.Error(t, err)
assert.ErrorIs(t, err, NewInsufficientBalanceError())
@ -368,7 +368,7 @@ func TestSendPaymentSync_IsolatedApp_BalanceInsufficientThenSufficient(t *testin
AmountMsat: 10000, // add extra to cover fee reserves max of(10 sats or 1%)
})
transaction, err = transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err = transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)

18
transactions/payments_test.go
View file

@ -32,7 +32,7 @@ func TestSendPaymentSync_NoApp(t *testing.T) {
}
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, metadata, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, metadata, svc.LNClient, nil, nil, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -62,7 +62,7 @@ func TestSendPaymentSync_0Amount(t *testing.T) {
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
amount := uint64(1234)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.Mock0AmountInvoice, &amount, metadata, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.Mock0AmountInvoice, &amount, metadata, svc.LNClient, nil, nil, 50)
assert.NoError(t, err)
assert.Equal(t, amount, transaction.AmountMsat)
@ -82,7 +82,7 @@ func TestSendPaymentSync_MetadataTooLarge(t *testing.T) {
metadata["randomkey"] = strings.Repeat("a", constants.INVOICE_METADATA_MAX_LENGTH-15) // json encoding adds 16 characters
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, metadata, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, metadata, svc.LNClient, nil, nil, 50)
assert.Error(t, err)
assert.Equal(t, fmt.Sprintf("encoded payment metadata provided is too large. Limit: %d Received: %d", constants.INVOICE_METADATA_MAX_LENGTH, constants.INVOICE_METADATA_MAX_LENGTH+1), err.Error())
@ -104,7 +104,7 @@ func TestSendPaymentSync_Duplicate_AlreadyPaid(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.Error(t, err)
assert.Equal(t, "this invoice has already been paid", err.Error())
@ -126,7 +126,7 @@ func TestSendPaymentSync_Duplicate_Pending(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.Error(t, err)
assert.Equal(t, "there is already a payment pending for this invoice", err.Error())
@ -148,7 +148,7 @@ func TestSendPaymentSync_Duplicate_Failed(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
_, err = transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, false)
_, err = transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.NoError(t, err)
}
@ -308,7 +308,7 @@ func TestSendPaymentSync_FailedRemovesFeeReserve(t *testing.T) {
svc.EventPublisher.RegisterSubscriber(mockEventConsumer)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.Error(t, err)
assert.Nil(t, transaction)
@ -338,7 +338,7 @@ func TestSendPaymentSync_PendingHasFeeReserve(t *testing.T) {
svc.LNClient.(*tests.MockLn).PayInvoiceResponses = append(svc.LNClient.(*tests.MockLn).PayInvoiceResponses, nil)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.Error(t, err)
assert.Nil(t, transaction)
@ -365,7 +365,7 @@ func TestConsumeEvent_DoesNotMarkFailedAsSuccessful(t *testing.T) {
svc.LNClient.(*tests.MockLn).PayInvoiceErrors = append(svc.LNClient.(*tests.MockLn).PayInvoiceErrors, errors.New("some error"))
svc.LNClient.(*tests.MockLn).PayInvoiceResponses = append(svc.LNClient.(*tests.MockLn).PayInvoiceResponses, nil)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockLNClientTransaction.Invoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.Error(t, err)
assert.Nil(t, transaction)

14
transactions/self_payments_test.go
View file

@ -34,7 +34,7 @@ func TestSendPaymentSync_SelfPayment_NoAppToNoApp(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -86,7 +86,7 @@ func TestSendPaymentSync_SelfPayment_NoAppToIsolatedApp(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -139,7 +139,7 @@ func TestSendPaymentSync_SelfPayment_NoAppToApp(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, nil, nil, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, nil, nil, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -208,7 +208,7 @@ func TestSendPaymentSync_SelfPayment_IsolatedAppToNoApp(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -283,7 +283,7 @@ func TestSendPaymentSync_SelfPayment_IsolatedAppToApp(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -365,7 +365,7 @@ func TestSendPaymentSync_SelfPayment_IsolatedAppToIsolatedApp(t *testing.T) {
svc.EventPublisher.RegisterSubscriber(mockEventConsumer)
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)
@ -457,7 +457,7 @@ func TestSendPaymentSync_SelfPayment_IsolatedAppToSelf(t *testing.T) {
})
transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, false)
transaction, err := transactionsService.SendPaymentSync(ctx, tests.MockInvoice, nil, nil, svc.LNClient, &app.ID, &dbRequestEvent.ID, 50)
assert.NoError(t, err)
assert.Equal(t, uint64(123000), transaction.AmountMsat)

6
transactions/transactions_service.go
View file

@ -38,7 +38,7 @@ type TransactionsService interface {
MakeInvoice(ctx context.Context, amount uint64, description string, descriptionHash string, expiry uint64, metadata map[string]interface{}, lnClient lnclient.LNClient, appId *uint, requestEventId *uint) (*Transaction, error)
LookupTransaction(ctx context.Context, paymentHash string, transactionType *string, lnClient lnclient.LNClient, appId *uint) (*Transaction, error)
ListTransactions(ctx context.Context, from, until, limit, offset uint64, unpaidOutgoing bool, unpaidIncoming bool, transactionType *string, lnClient lnclient.LNClient, appId *uint, forceFilterByAppId bool) (transactions []Transaction, totalCount uint64, err error)
SendPaymentSync(ctx context.Context, payReq string, amountMsat *uint64, metadata map[string]interface{}, lnClient lnclient.LNClient, appId *uint, requestEventId *uint, isHoldInvoice bool) (*Transaction, error)
SendPaymentSync(ctx context.Context, payReq string, amountMsat *uint64, metadata map[string]interface{}, lnClient lnclient.LNClient, appId *uint, requestEventId *uint, timeoutSeconds int64) (*Transaction, error)
SendKeysend(ctx context.Context, amount uint64, destination string, customRecords []lnclient.TLVRecord, preimage string, lnClient lnclient.LNClient, appId *uint, requestEventId *uint) (*Transaction, error)
}
@ -188,7 +188,7 @@ func (svc *transactionsService) MakeInvoice(ctx context.Context, amount uint64,
return &dbTransaction, nil
}
func (svc *transactionsService) SendPaymentSync(ctx context.Context, payReq string, amountMsat *uint64, metadata map[string]interface{}, lnClient lnclient.LNClient, appId *uint, requestEventId *uint, isHoldInvoice bool) (*Transaction, error) {
func (svc *transactionsService) SendPaymentSync(ctx context.Context, payReq string, amountMsat *uint64, metadata map[string]interface{}, lnClient lnclient.LNClient, appId *uint, requestEventId *uint, timeoutSeconds int64) (*Transaction, error) {
var metadataBytes []byte
if metadata != nil {
var err error
@ -293,7 +293,7 @@ func (svc *transactionsService) SendPaymentSync(ctx context.Context, payReq stri
if selfPayment {
response, err = svc.interceptSelfPayment(paymentRequest.PaymentHash)
} else {
response, err = lnClient.SendPaymentSync(ctx, payReq, amountMsat, isHoldInvoice)
response, err = lnClient.SendPaymentSync(ctx, payReq, amountMsat, timeoutSeconds)
}
if err != nil {