Merge pull request #7654 from ErikEk/listchaintxns-add-txhash

rpc: add gettx command to walletrpc

cmd/lncli/commands.go

@@ -1853,9 +1853,9 @@ var listChainTxnsCommand = cli.Command{
 		cli.Int64Flag{
 			Name: "end_height",
 			Usage: "the block height until which to list " +
-				"transactions, inclusive, to get transactions " +
-				"until the chain tip, including unconfirmed, " +
-				"set this value to -1",
+				"transactions, inclusive, to get " +
+				"transactions until the chain tip, including " +
+				"unconfirmed, set this value to -1",
 		},
 	},
 	Description: `

cmd/lncli/walletrpc_active.go

@@ -74,6 +74,7 @@ func walletCommands() []cli.Command {
 				listSweepsCommand,
 				labelTxCommand,
 				publishTxCommand,
+				getTxCommand,
 				releaseOutputCommand,
 				leaseOutputCommand,
 				listLeasesCommand,
@@ -561,6 +562,43 @@ func publishTransaction(ctx *cli.Context) error {
 	return nil
 }
 
+var getTxCommand = cli.Command{
+	Name:      "gettx",
+	Usage:     "Returns details of a transaction.",
+	ArgsUsage: "txid",
+	Description: `
+	Query the transaction using the given transaction id and return its 
+	details. An error is returned if the transaction is not found.
+	`,
+	Action: actionDecorator(getTransaction),
+}
+
+func getTransaction(ctx *cli.Context) error {
+	ctxc := getContext()
+
+	// Display the command's help message if we do not have the expected
+	// number of arguments/flags.
+	if ctx.NArg() != 1 {
+		return cli.ShowCommandHelp(ctx, "gettx")
+	}
+
+	walletClient, cleanUp := getWalletClient(ctx)
+	defer cleanUp()
+
+	req := &walletrpc.GetTransactionRequest{
+		Txid: ctx.Args().First(),
+	}
+
+	res, err := walletClient.GetTransaction(ctxc, req)
+	if err != nil {
+		return err
+	}
+
+	printRespJSON(res)
+
+	return nil
+}
+
 // utxoLease contains JSON annotations for a lease on an unspent output.
 type utxoLease struct {
 	ID         string   `json:"id"`

docs/release-notes/release-notes-0.18.0.md

@@ -78,6 +78,9 @@
   running this new version, please make sure to upgrade your client application
   to include this new status so it can understand the RPC response properly.
   
+* Adds a new rpc endpoint gettx to the walletrpc sub-server to [fetch 
+  transaction details](https://github.com/lightningnetwork/lnd/pull/7654).
+
 ## lncli Additions
 
 # Improvements
@@ -175,6 +178,7 @@
 * Andras Banki-Horvath
 * Carla Kirk-Cohen
 * Elle Mouton
+* ErikEk
 * Keagan McClelland
 * Marcos Fernandez Perez
 * Matt Morehouse

itest/lnd_misc_test.go

@@ -829,32 +829,22 @@ func testSweepAllCoins(ht *lntest.HarnessTest) {
 	// assertTxLabel is a helper function which finds a target tx in our
 	// set of transactions and checks that it has the desired label.
 	assertTxLabel := func(targetTx, label string) error {
-		// List all transactions relevant to our wallet, and find the
-		// tx so that we can check the correct label has been set.
-		txResp := ainz.RPC.GetTransactions(nil)
+		// Get the transaction from our wallet so that we can check
+		// that the correct label has been set.
+		txResp := ainz.RPC.GetTransaction(
+			&walletrpc.GetTransactionRequest{
+				Txid: targetTx,
+			},
+		)
+		require.NotNilf(ht, txResp, "target tx %v not found", targetTx)
 
-		var target *lnrpc.Transaction
-
-		// First we need to find the target tx.
-		for _, txn := range txResp.Transactions {
-			if txn.TxHash == targetTx {
-				target = txn
-				break
-			}
-		}
-
-		// If we cannot find it, return an error.
-		if target == nil {
-			return fmt.Errorf("target tx %v not found", targetTx)
-		}
-
-		// Otherwise, check the labels are matched.
-		if target.Label == label {
+		// Make sure the labels match.
+		if txResp.Label == label {
 			return nil
 		}
 
 		return fmt.Errorf("labels not match, want: "+
-			"%v, got %v", label, target.Label)
+			"%v, got %v", label, txResp.Label)
 	}
 
 	// waitTxLabel waits until the desired tx label is found or timeout.

lnrpc/walletrpc/walletkit.pb.gw.go

@@ -254,6 +254,42 @@ func local_request_WalletKit_NextAddr_0(ctx context.Context, marshaler runtime.M
 
 }
 
+var (
+	filter_WalletKit_GetTransaction_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_WalletKit_GetTransaction_0(ctx context.Context, marshaler runtime.Marshaler, client WalletKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetTransactionRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_WalletKit_GetTransaction_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.GetTransaction(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_WalletKit_GetTransaction_0(ctx context.Context, marshaler runtime.Marshaler, server WalletKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetTransactionRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_WalletKit_GetTransaction_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.GetTransaction(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 var (
 	filter_WalletKit_ListAccounts_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
@@ -1043,6 +1079,29 @@ func RegisterWalletKitHandlerServer(ctx context.Context, mux *runtime.ServeMux,
 
 	})
 
+	mux.Handle("GET", pattern_WalletKit_GetTransaction_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/walletrpc.WalletKit/GetTransaction", runtime.WithHTTPPathPattern("/v2/wallet/tx"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_WalletKit_GetTransaction_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_WalletKit_GetTransaction_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_WalletKit_ListAccounts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1638,6 +1697,26 @@ func RegisterWalletKitHandlerClient(ctx context.Context, mux *runtime.ServeMux,
 
 	})
 
+	mux.Handle("GET", pattern_WalletKit_GetTransaction_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/walletrpc.WalletKit/GetTransaction", runtime.WithHTTPPathPattern("/v2/wallet/tx"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_WalletKit_GetTransaction_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_WalletKit_GetTransaction_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_WalletKit_ListAccounts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -2016,6 +2095,8 @@ var (
 
 	pattern_WalletKit_NextAddr_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "wallet", "address", "next"}, ""))
 
+	pattern_WalletKit_GetTransaction_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "wallet", "tx"}, ""))
+
 	pattern_WalletKit_ListAccounts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "wallet", "accounts"}, ""))
 
 	pattern_WalletKit_RequiredReserve_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "wallet", "reserve"}, ""))
@@ -2068,6 +2149,8 @@ var (
 
 	forward_WalletKit_NextAddr_0 = runtime.ForwardResponseMessage
 
+	forward_WalletKit_GetTransaction_0 = runtime.ForwardResponseMessage
+
 	forward_WalletKit_ListAccounts_0 = runtime.ForwardResponseMessage
 
 	forward_WalletKit_RequiredReserve_0 = runtime.ForwardResponseMessage

lnrpc/walletrpc/walletkit.pb.json.go

@@ -197,6 +197,31 @@ func RegisterWalletKitJSONCallbacks(registry map[string]func(ctx context.Context
 		callback(string(respBytes), nil)
 	}
 
+	registry["walletrpc.WalletKit.GetTransaction"] = func(ctx context.Context,
+		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
+
+		req := &GetTransactionRequest{}
+		err := marshaler.Unmarshal([]byte(reqJSON), req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		client := NewWalletKitClient(conn)
+		resp, err := client.GetTransaction(ctx, req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		respBytes, err := marshaler.Marshal(resp)
+		if err != nil {
+			callback("", err)
+			return
+		}
+		callback(string(respBytes), nil)
+	}
+
 	registry["walletrpc.WalletKit.ListAccounts"] = func(ctx context.Context,
 		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
 

lnrpc/walletrpc/walletkit.proto

@@ -75,6 +75,11 @@ service WalletKit {
     */
     rpc NextAddr (AddrRequest) returns (AddrResponse);
 
+    /* lncli: `wallet gettx`
+    GetTransaction returns details for a transaction found in the wallet.
+    */
+    rpc GetTransaction (GetTransactionRequest) returns (lnrpc.Transaction);
+
     /* lncli: `wallet accounts list`
     ListAccounts retrieves all accounts belonging to the wallet by default. A
     name and key scope filter can be provided to filter through all of the
@@ -556,6 +561,11 @@ message ListAddressesResponse {
     repeated AccountWithAddresses account_with_addresses = 1;
 }
 
+message GetTransactionRequest {
+    // The txid of the transaction.
+    string txid = 1;
+}
+
 message SignMessageWithAddrRequest {
     // The message to be signed. When using REST, this field must be encoded as
     // base64.

lnrpc/walletrpc/walletkit.swagger.json

@@ -663,6 +663,36 @@
       }
     },
     "/v2/wallet/tx": {
+      "get": {
+        "summary": "lncli: `wallet gettx`\nGetTransaction returns details for a transaction found in the wallet.",
+        "operationId": "WalletKit_GetTransaction",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/lnrpcTransaction"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "txid",
+            "description": "The txid of the transaction.",
+            "in": "query",
+            "required": false,
+            "type": "string"
+          }
+        ],
+        "tags": [
+          "WalletKit"
+        ]
+      },
       "post": {
         "summary": "lncli: `wallet publishtx`\nPublishTransaction attempts to publish the passed transaction to the\nnetwork. Once this returns without an error, the wallet will continually\nattempt to re-broadcast the transaction on start up, until it enters the\nchain.",
         "operationId": "WalletKit_PublishTransaction",

lnrpc/walletrpc/walletkit.yaml

@@ -29,6 +29,8 @@ http:
     - selector: walletrpc.WalletKit.NextAddr
       post: "/v2/wallet/address/next"
       body: "*"
+    - selector: walletrpc.WalletKit.GetTransaction
+      get: "/v2/wallet/tx"
     - selector: walletrpc.WalletKit.PublishTransaction
       post: "/v2/wallet/tx"
       body: "*"

lnrpc/walletrpc/walletkit_grpc.pb.go

@@ -4,6 +4,7 @@ package walletrpc
 
 import (
 	context "context"
+	lnrpc "github.com/lightningnetwork/lnd/lnrpc"
 	signrpc "github.com/lightningnetwork/lnd/lnrpc/signrpc"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -48,6 +49,9 @@ type WalletKitClient interface {
 	DeriveKey(ctx context.Context, in *signrpc.KeyLocator, opts ...grpc.CallOption) (*signrpc.KeyDescriptor, error)
 	// NextAddr returns the next unused address within the wallet.
 	NextAddr(ctx context.Context, in *AddrRequest, opts ...grpc.CallOption) (*AddrResponse, error)
+	// lncli: `wallet gettx`
+	// GetTransaction returns details for a transaction found in the wallet.
+	GetTransaction(ctx context.Context, in *GetTransactionRequest, opts ...grpc.CallOption) (*lnrpc.Transaction, error)
 	// lncli: `wallet accounts list`
 	// ListAccounts retrieves all accounts belonging to the wallet by default. A
 	// name and key scope filter can be provided to filter through all of the
@@ -326,6 +330,15 @@ func (c *walletKitClient) NextAddr(ctx context.Context, in *AddrRequest, opts ..
 	return out, nil
 }
 
+func (c *walletKitClient) GetTransaction(ctx context.Context, in *GetTransactionRequest, opts ...grpc.CallOption) (*lnrpc.Transaction, error) {
+	out := new(lnrpc.Transaction)
+	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/GetTransaction", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *walletKitClient) ListAccounts(ctx context.Context, in *ListAccountsRequest, opts ...grpc.CallOption) (*ListAccountsResponse, error) {
 	out := new(ListAccountsResponse)
 	err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/ListAccounts", in, out, opts...)
@@ -521,6 +534,9 @@ type WalletKitServer interface {
 	DeriveKey(context.Context, *signrpc.KeyLocator) (*signrpc.KeyDescriptor, error)
 	// NextAddr returns the next unused address within the wallet.
 	NextAddr(context.Context, *AddrRequest) (*AddrResponse, error)
+	// lncli: `wallet gettx`
+	// GetTransaction returns details for a transaction found in the wallet.
+	GetTransaction(context.Context, *GetTransactionRequest) (*lnrpc.Transaction, error)
 	// lncli: `wallet accounts list`
 	// ListAccounts retrieves all accounts belonging to the wallet by default. A
 	// name and key scope filter can be provided to filter through all of the
@@ -754,6 +770,9 @@ func (UnimplementedWalletKitServer) DeriveKey(context.Context, *signrpc.KeyLocat
 func (UnimplementedWalletKitServer) NextAddr(context.Context, *AddrRequest) (*AddrResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method NextAddr not implemented")
 }
+func (UnimplementedWalletKitServer) GetTransaction(context.Context, *GetTransactionRequest) (*lnrpc.Transaction, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetTransaction not implemented")
+}
 func (UnimplementedWalletKitServer) ListAccounts(context.Context, *ListAccountsRequest) (*ListAccountsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListAccounts not implemented")
 }
@@ -947,6 +966,24 @@ func _WalletKit_NextAddr_Handler(srv interface{}, ctx context.Context, dec func(
 	return interceptor(ctx, in, info, handler)
 }
 
+func _WalletKit_GetTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetTransactionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WalletKitServer).GetTransaction(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/walletrpc.WalletKit/GetTransaction",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WalletKitServer).GetTransaction(ctx, req.(*GetTransactionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _WalletKit_ListAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ListAccountsRequest)
 	if err := dec(in); err != nil {
@@ -1306,6 +1343,10 @@ var WalletKit_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "NextAddr",
 			Handler:    _WalletKit_NextAddr_Handler,
 		},
+		{
+			MethodName: "GetTransaction",
+			Handler:    _WalletKit_GetTransaction_Handler,
+		},
 		{
 			MethodName: "ListAccounts",
 			Handler:    _WalletKit_ListAccounts_Handler,

lnrpc/walletrpc/walletkit_server.go

@@ -80,6 +80,10 @@ var (
 			Entity: "address",
 			Action: "read",
 		}},
+		"/walletrpc.WalletKit/GetTransaction": {{
+			Entity: "onchain",
+			Action: "read",
+		}},
 		"/walletrpc.WalletKit/PublishTransaction": {{
 			Entity: "onchain",
 			Action: "write",
@@ -612,6 +616,29 @@ func (w *WalletKit) NextAddr(ctx context.Context,
 	}, nil
 }
 
+// GetTransaction returns a transaction from the wallet given its hash.
+func (w *WalletKit) GetTransaction(_ context.Context,
+	req *GetTransactionRequest) (*lnrpc.Transaction, error) {
+
+	// If the client doesn't specify a hash, then there's nothing to
+	// return.
+	if req.Txid == "" {
+		return nil, fmt.Errorf("must provide a transaction hash")
+	}
+
+	txHash, err := chainhash.NewHashFromStr(req.Txid)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := w.cfg.Wallet.GetTransactionDetails(txHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return lnrpc.RPCTransaction(res), nil
+}
+
 // Attempts to publish the passed transaction to the network. Once this returns
 // without an error, the wallet will continually attempt to re-broadcast the
 // transaction on start up, until it enters the chain.

lntest/mock/walletcontroller.go

@@ -233,6 +233,13 @@ func (w *WalletController) PublishTransaction(tx *wire.MsgTx, _ string) error {
 	return nil
 }
 
+// GetTransactionDetails currently does nothing.
+func (w *WalletController) GetTransactionDetails(
+	txHash *chainhash.Hash) (*lnwallet.TransactionDetail, error) {
+
+	return nil, nil
+}
+
 // LabelTransaction currently does nothing.
 func (w *WalletController) LabelTransaction(chainhash.Hash, string,
 	bool) error {

lntest/rpc/wallet_kit.go

@@ -3,6 +3,7 @@ package rpc
 import (
 	"context"
 
+	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/stretchr/testify/require"
@@ -196,6 +197,19 @@ func (h *HarnessRPC) PublishTransaction(
 	return resp
 }
 
+// GetTransaction makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) GetTransaction(
+	req *walletrpc.GetTransactionRequest) *lnrpc.Transaction {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.GetTransaction(ctxt, req)
+	h.NoError(err, "GetTransaction")
+
+	return resp
+}
+
 // BumpFee makes a RPC call to the node's WalletKitClient and asserts.
 func (h *HarnessRPC) BumpFee(
 	req *walletrpc.BumpFeeRequest) *walletrpc.BumpFeeResponse {

lnwallet/btcwallet/btcwallet.go

@@ -1285,6 +1285,45 @@ func getPreviousOutpoints(wireTx *wire.MsgTx,
 	return previousOutpoints
 }
 
+// GetTransactionDetails returns details of a transaction given its
+// transaction hash.
+func (b *BtcWallet) GetTransactionDetails(
+	txHash *chainhash.Hash) (*lnwallet.TransactionDetail, error) {
+
+	// Grab the best block the wallet knows of, we'll use this to calculate
+	// # of confirmations shortly below.
+	bestBlock := b.wallet.Manager.SyncedTo()
+	currentHeight := bestBlock.Height
+	tx, err := b.wallet.GetTransaction(*txHash)
+	if err != nil {
+		return nil, err
+	}
+
+	// For both confirmed and unconfirmed transactions, create a
+	// TransactionDetail which re-packages the data returned by the base
+	// wallet.
+	if tx.Confirmations > 0 {
+		txDetails, err := minedTransactionsToDetails(
+			currentHeight,
+			base.Block{
+				Transactions: []base.TransactionSummary{
+					tx.Summary,
+				},
+				Hash:      tx.BlockHash,
+				Height:    tx.Height,
+				Timestamp: tx.Summary.Timestamp},
+			b.netParams,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		return txDetails[0], nil
+	}
+
+	return unminedTransactionsToDetail(tx.Summary, b.netParams)
+}
+
 // minedTransactionsToDetails is a helper function which converts a summary
 // information about mined transactions to a TransactionDetail.
 func minedTransactionsToDetails(

lnwallet/interface.go

@@ -356,6 +356,11 @@ type WalletController interface {
 	CreateSimpleTx(outputs []*wire.TxOut, feeRate chainfee.SatPerKWeight,
 		minConfs int32, dryRun bool) (*txauthor.AuthoredTx, error)
 
+	// GetTransactionDetails returns a detailed description of a transaction
+	// given its transaction hash.
+	GetTransactionDetails(txHash *chainhash.Hash) (
+		*TransactionDetail, error)
+
 	// ListUnspentWitness returns all unspent outputs which are version 0
 	// witness programs. The 'minConfs' and 'maxConfs' parameters
 	// indicate the minimum and maximum number of confirmations an output

lnwallet/mock.go

@@ -243,6 +243,13 @@ func (w *mockWalletController) PublishTransaction(tx *wire.MsgTx,
 	return nil
 }
 
+// GetTransactionDetails currently does nothing.
+func (w *mockWalletController) GetTransactionDetails(*chainhash.Hash) (
+	*TransactionDetail, error) {
+
+	return nil, nil
+}
+
 // LabelTransaction currently does nothing.
 func (w *mockWalletController) LabelTransaction(chainhash.Hash, string,
 	bool) error {

lnwallet/test/test_interface.go

@@ -1685,6 +1685,30 @@ func newTx(t *testing.T, r *rpctest.Harness, pubKey *btcec.PublicKey,
 	return tx1
 }
 
+// testGetTransactionDetails checks that GetTransactionDetails returns the
+// correct amount after a transaction has been sent from alice to bob.
+func testGetTransactionDetails(r *rpctest.Harness,
+	alice, bob *lnwallet.LightningWallet, t *testing.T) {
+
+	const txFee = int64(14500)
+
+	bobPkScript := newPkScript(t, bob, lnwallet.WitnessPubKey)
+	txFeeRate := chainfee.SatPerKWeight(2500)
+	amountSats := btcutil.Amount(btcutil.SatoshiPerBitcoin - txFee)
+	output := &wire.TxOut{
+		Value:    int64(amountSats),
+		PkScript: bobPkScript,
+	}
+	tx := sendCoins(t, r, alice, bob, output, txFeeRate, true, 1)
+	txHash := tx.TxHash()
+	assertTxInWallet(t, alice, txHash, true)
+	assertTxInWallet(t, bob, txHash, true)
+
+	txDetails, err := bob.GetTransactionDetails(&txHash)
+	require.NoError(t, err, "unable to receive transaction details")
+	require.Equal(t, txDetails.Value, amountSats, "tx value")
+}
+
 // testPublishTransaction checks that PublishTransaction returns the expected
 // error types in case the transaction being published conflicts with the
 // current mempool or chain.
@@ -2794,6 +2818,10 @@ var walletTests = []walletTestCase{
 		name: "transaction details",
 		test: testListTransactionDetails,
 	},
+	{
+		name: "get transaction details",
+		test: testGetTransactionDetails,
+	},
 	{
 		name: "publish transaction",
 		test: testPublishTransaction,