fix: remove dead code in CLN backend from ListTransactions

Author: daywalker90

lnclient/cln/cln.go

@@ -1196,258 +1196,7 @@ func (c *CLNService) ListPeers(ctx context.Context) ([]lnclient.PeerDetails, err
 }
 
 func (c *CLNService) ListTransactions(ctx context.Context, from uint64, until uint64, limit uint64, offset uint64, unpaid bool, invoiceType string) (transactions []lnclient.Transaction, err error) {
-	logger.Logger.WithFields(logrus.Fields{
-		"from":        from,
-		"until":       until,
-		"limit":       limit,
-		"offset":      offset,
-		"unpaid":      unpaid,
-		"invoiceType": invoiceType,
-	}).Debug("List Transactions")
-
-	pageSize := uint32(200)
-
-	fetchInvoices := func() ([]lnclient.Transaction, error) {
-		var out []lnclient.Transaction
-		seen := make(map[uint64]struct{})
-
-		waitReq := &clngrpc.WaitRequest{
-			Subsystem: clngrpc.WaitRequest_INVOICES,
-			Indexname: clngrpc.WaitRequest_CREATED,
-			Nextvalue: 0,
-		}
-		waitResp, err := c.client.Wait(ctx, waitReq)
-		if err != nil {
-			logger.Logger.WithError(err).Error("wait failed")
-			return nil, fmt.Errorf("wait failed: %w", err)
-		}
-
-		if waitResp == nil || waitResp.Created == nil {
-			return nil, fmt.Errorf("wait result missing created: %w", err)
-		}
-		currentIndex := uint64(0)
-		if *waitResp.Created > uint64(pageSize)-1 {
-			currentIndex -= uint64(pageSize) - 1
-		}
-
-		firstStart := uint64(0)
-		firstLimit := uint32(1)
-		firstReq := &clngrpc.ListinvoicesRequest{
-			Index: clngrpc.ListinvoicesRequest_CREATED.Enum(),
-			Start: &firstStart,
-			Limit: &firstLimit,
-		}
-		firstResp, err := c.client.ListInvoices(ctx, firstReq)
-		if err != nil {
-			logger.Logger.WithError(err).Error("listinvoices failed")
-			return nil, fmt.Errorf("listinvoices failed: %w", err)
-		}
-		firstIndex := uint64(0)
-		if firstResp != nil && len(firstResp.Invoices) == 1 && firstResp.Invoices[0].UpdatedIndex != nil {
-			firstIndex = *firstResp.Invoices[0].UpdatedIndex
-
-		}
-
-		myLimit := pageSize
-
-		for {
-			req := &clngrpc.ListinvoicesRequest{
-				Index: clngrpc.ListinvoicesRequest_CREATED.Enum(),
-				Start: &currentIndex,
-				Limit: &myLimit,
-			}
-
-			resp, err := c.client.ListInvoices(ctx, req)
-			if err != nil {
-				logger.Logger.WithError(err).Error("listinvoices failed")
-				return nil, fmt.Errorf("listinvoices failed: %w", err)
-			}
-
-			for _, invoice := range resp.Invoices {
-				idx := uint64(0)
-				if invoice.CreatedIndex != nil {
-					idx = *invoice.CreatedIndex
-				}
-
-				if idx != 0 {
-					if _, ok := seen[idx]; ok {
-						continue
-					}
-					seen[idx] = struct{}{}
-				}
-
-				if !unpaid && invoice.Status != clngrpc.ListinvoicesInvoices_PAID {
-					continue
-				}
-
-				tx, err := c.clnInvoiceToTransaction(ctx, invoice)
-				if err != nil {
-					logger.Logger.WithError(err).Error("failed to convert invoice to transaction")
-					return nil, fmt.Errorf("failed to convert invoice to transaction: %w", err)
-				}
-				out = append(out, *tx)
-			}
-
-			if currentIndex <= 1 || currentIndex <= firstIndex {
-				break
-			}
-
-			if uint64(len(out)) >= offset+limit {
-				break
-			}
-
-			myLimit = min(pageSize, uint32(currentIndex))
-
-			if currentIndex > uint64(pageSize) {
-				currentIndex -= uint64(pageSize)
-			} else {
-				currentIndex = 0
-			}
-		}
-
-		return out, nil
-	}
-
-	fetchPays := func() ([]lnclient.Transaction, error) {
-		var out []lnclient.Transaction
-		seen := make(map[uint64]struct{})
-
-		waitReq := &clngrpc.WaitRequest{
-			Subsystem: clngrpc.WaitRequest_SENDPAYS,
-			Indexname: clngrpc.WaitRequest_CREATED,
-			Nextvalue: 0,
-		}
-		waitResp, err := c.client.Wait(ctx, waitReq)
-		if err != nil {
-			logger.Logger.WithError(err).Error("wait failed")
-			return nil, fmt.Errorf("wait failed: %w", err)
-		}
-
-		if waitResp == nil || waitResp.Created == nil {
-			return nil, fmt.Errorf("wait result missing created: %w", err)
-		}
-		currentIndex := uint64(0)
-		if *waitResp.Created > uint64(pageSize)-1 {
-			currentIndex -= uint64(pageSize) - 1
-		}
-
-		firstStart := uint64(0)
-		firstLimit := uint32(1)
-		firstReq := &clngrpc.ListpaysRequest{
-			Index: clngrpc.ListpaysRequest_CREATED.Enum(),
-			Start: &firstStart,
-			Limit: &firstLimit,
-		}
-		firstResp, err := c.client.ListPays(ctx, firstReq)
-		if err != nil {
-			logger.Logger.WithError(err).Error("listpays failed")
-			return nil, fmt.Errorf("listpays failed: %w", err)
-		}
-		firstIndex := uint64(0)
-		if firstResp != nil && len(firstResp.Pays) == 1 && firstResp.Pays[0].UpdatedIndex != nil {
-			firstIndex = *firstResp.Pays[0].UpdatedIndex
-
-		}
-
-		myLimit := pageSize
-
-		for {
-			req := &clngrpc.ListpaysRequest{
-				Start: &currentIndex,
-				Limit: &myLimit,
-			}
-
-			if !unpaid {
-				req.Status = clngrpc.ListpaysRequest_COMPLETE.Enum()
-			}
-
-			resp, err := c.client.ListPays(ctx, req)
-			if err != nil {
-				logger.Logger.WithError(err).Error("listpays failed")
-				return nil, fmt.Errorf("listpays failed: %w", err)
-			}
-
-			for _, pay := range resp.Pays {
-				idx := uint64(0)
-				if pay.CreatedIndex != nil {
-					idx = *pay.CreatedIndex
-				}
-
-				if idx != 0 {
-					if _, ok := seen[idx]; ok {
-						continue
-					}
-					seen[idx] = struct{}{}
-				}
-
-				if !unpaid && pay.Status != clngrpc.ListpaysPays_COMPLETE {
-					continue
-				}
-
-				tx, err := c.clnPayToTransaction(ctx, pay)
-				if err != nil {
-					logger.Logger.WithError(err).Error("failed to convert pay to transaction")
-					return nil, fmt.Errorf("failed to convert pay to transaction: %w", err)
-				}
-				out = append(out, *tx)
-			}
-
-			if currentIndex <= 1 || currentIndex <= firstIndex {
-				break
-			}
-
-			if uint64(len(out)) >= offset+limit {
-				break
-			}
-
-			myLimit = min(pageSize, uint32(currentIndex))
-
-			if currentIndex > uint64(pageSize) {
-				currentIndex -= uint64(pageSize)
-			} else {
-				currentIndex = 0
-			}
-		}
-
-		return out, nil
-	}
-
-	if invoiceType == "" || invoiceType == "incoming" {
-		invoices, err := fetchInvoices()
-		if err != nil {
-			return nil, err
-		}
-
-		transactions = append(transactions, invoices...)
-
-	}
-
-	if invoiceType == "" || invoiceType == "outgoing" {
-		pays, err := fetchPays()
-		if err != nil {
-			return nil, err
-		}
-
-		transactions = append(transactions, pays...)
-
-	}
-
-	sort.Slice(transactions, func(i, j int) bool {
-		return transactions[i].CreatedAt > transactions[j].CreatedAt
-	})
-
-	l := len(transactions)
-
-	var lim int
-	if limit > uint64(l) {
-		lim = l
-	} else {
-		lim = int(limit)
-	}
-
-	transactions = transactions[:lim]
-
-	return transactions, nil
+	return nil, fmt.Errorf("obsolete function")
 }
 
 func (c *CLNService) LookupInvoice(ctx context.Context, paymentHash string) (transaction *lnclient.Transaction, err error) {
@@ -1542,107 +1291,6 @@ func (c *CLNService) clnInvoiceToTransaction(ctx context.Context, invoice *clngr
 	return transaction, nil
 }
 
-func (c *CLNService) clnPayToTransaction(ctx context.Context, pay *clngrpc.ListpaysPays) (*lnclient.Transaction, error) {
-
-	var invString string
-	if pay.Bolt11 != nil {
-		invString = *pay.Bolt11
-	} else if pay.Bolt12 != nil {
-		invString = *pay.Bolt12
-	} else {
-		invString = ""
-	}
-
-	descriptionHash := ""
-	var amount int64
-	var decodedInvoice *clngrpc.DecodeResponse
-	var err error
-
-	if invString != "" {
-		decodedInvoice, err = c.client.Decode(ctx, &clngrpc.DecodeRequest{String_: invString})
-		if err != nil {
-			logger.Logger.WithError(err).Error("decode failed")
-			return nil, fmt.Errorf("decode failed: %w", err)
-		}
-		if decodedInvoice == nil {
-			return nil, fmt.Errorf("decoded invoice is nil")
-		}
-
-		if !decodedInvoice.Valid {
-			return nil, fmt.Errorf("decoded invoice is not valid")
-		}
-
-		switch decodedInvoice.ItemType {
-		case clngrpc.DecodeResponse_BOLT11_INVOICE:
-			descriptionHash = hex.EncodeToString(decodedInvoice.DescriptionHash)
-		case clngrpc.DecodeResponse_BOLT12_INVOICE:
-			descriptionHash = ""
-		default:
-			return nil, fmt.Errorf("not an invoice")
-		}
-
-	}
-
-	if pay.AmountMsat != nil {
-		amount = int64(pay.AmountMsat.Msat)
-	} else if decodedInvoice != nil {
-		switch decodedInvoice.ItemType {
-		case clngrpc.DecodeResponse_BOLT11_INVOICE:
-			amount = int64(decodedInvoice.GetAmountMsat().Msat)
-		case clngrpc.DecodeResponse_BOLT12_INVOICE:
-			amount = int64(decodedInvoice.GetInvoiceAmountMsat().Msat)
-		default:
-			return nil, fmt.Errorf("not an invoice")
-		}
-	} else {
-		return nil, fmt.Errorf("amount and invoice missing from payment")
-	}
-
-	var description string
-	if pay.Description != nil {
-		description = *pay.Description
-	} else {
-		switch decodedInvoice.ItemType {
-		case clngrpc.DecodeResponse_BOLT11_INVOICE:
-			description = decodedInvoice.GetDescription()
-		case clngrpc.DecodeResponse_BOLT12_INVOICE:
-			description = decodedInvoice.GetOfferDescription()
-		default:
-			return nil, fmt.Errorf("not an invoice")
-		}
-	}
-
-	var feesPaid int64
-	if pay.AmountSentMsat != nil {
-		feesPaid = int64(pay.AmountSentMsat.Msat) - amount
-	} else {
-		feesPaid = 0
-	}
-
-	var settledAt *int64
-	if pay.CompletedAt != nil {
-		completedAt := int64(*pay.CompletedAt)
-		settledAt = &completedAt
-	}
-
-	transaction := &lnclient.Transaction{
-		Type:            "outgoing",
-		Invoice:         invString,
-		Description:     description,
-		DescriptionHash: descriptionHash,
-		Preimage:        hex.EncodeToString(pay.Preimage),
-		PaymentHash:     hex.EncodeToString(pay.PaymentHash),
-		Amount:          amount,
-		FeesPaid:        feesPaid,
-		CreatedAt:       int64(pay.CreatedAt),
-		ExpiresAt:       nil,
-		SettledAt:       settledAt,
-		Metadata:        lnclient.Metadata{},
-		SettleDeadline:  nil,
-	}
-	return transaction, nil
-}
-
 func (c *CLNService) MakeHoldInvoice(ctx context.Context, amount int64, description string, descriptionHash string, expiry int64, paymentHash string) (transaction *lnclient.Transaction, err error) {
 	if c.clientHold == nil {
 		return nil, errors.New("hold plugin not configured")