highperfocused/lnd
1
0
Fork 0
mirror of https://github.com/lightningnetwork/lnd.git synced 2025-04-03 09:28:34 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6596 from priyanshiiit/addressbalance

Browse Source 
lnrpc+lnwallet: adds listaddresses RPC
This commit is contained in:
Oliver Gugger 2022-08-18 10:52:23 +02:00 committed by GitHub
commit 52c2f447d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 1498 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
cmd/lncli/walletrpc_active.go
View File

@ -43,6 +43,16 @@ var (
importPubKeyCommand,
},
}
// addressesCommand is a wallet subcommand that is responsible for
// address management operations.
addressesCommand = cli.Command{
Name: "addresses",
Usage: "Interact with wallet addresses.",
Subcommands: []cli.Command{
listAddressesCommand,
},
}
)
// walletCommands will return the set of commands to enable for walletrpc
@ -67,6 +77,7 @@ func walletCommands() []cli.Command {
psbtCommand,
accountsCommand,
requiredReserveCommand,
addressesCommand,
},
},
}
@ -1131,6 +1142,54 @@ func requiredReserve(ctx *cli.Context) error {
return nil
}
var listAddressesCommand = cli.Command{
Name: "list",
Usage: "Retrieve information of existing on-chain wallet addresses.",
Description: `
Retrieves information of existing on-chain wallet addresses along with
their type, internal/external and balance.
`,
Flags: []cli.Flag{
cli.StringFlag{
Name: "account_name",
Usage: "(optional) only addreses matching this account " +
"are returned",
},
cli.BoolFlag{
Name: "show_custom_accounts",
Usage: "(optional) set this to true to show lnd's " +
"custom accounts",
},
},
Action: actionDecorator(listAddresses),
}
func listAddresses(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() > 0 || ctx.NumFlags() > 2 {
return cli.ShowCommandHelp(ctx, "list")
}
walletClient, cleanUp := getWalletClient(ctx)
defer cleanUp()
req := &walletrpc.ListAddressesRequest{
AccountName: ctx.String("account_name"),
ShowCustomAccounts: ctx.Bool("show_custom_accounts"),
}
resp, err := walletClient.ListAddresses(ctxc, req)
if err != nil {
return err
}
printRespJSON(resp)
return nil
}
var importAccountCommand = cli.Command{
Name: "import",
Usage: "Import an on-chain account into the wallet through its " +

3
docs/release-notes/release-notes-0.16.0.md
View File

@ -16,6 +16,8 @@ transaction](https://github.com/lightningnetwork/lnd/pull/6730).
that were signed by our wallet. Prior to this change `SignPsbt` didn't
indicate whether the Psbt held any inputs for our wallet to sign.
* [Add list addresses RPC](https://github.com/lightningnetwork/lnd/pull/6596).
## Misc
* Warning messages from peers are now recognized and
[logged](https://github.com/lightningnetwork/lnd/pull/6546) by lnd.
@ -52,3 +54,4 @@ transaction](https://github.com/lightningnetwork/lnd/pull/6730).
* hieblmi
* Olaoluwa Osuntokun
* Oliver Gugger
* Priyansh Rastogi

1029
lnrpc/walletrpc/walletkit.pb.go
View File

File diff suppressed because it is too large Load Diff

83
lnrpc/walletrpc/walletkit.pb.gw.go
View File

@ -326,6 +326,42 @@ func local_request_WalletKit_RequiredReserve_0(ctx context.Context, marshaler ru
}
var (
filter_WalletKit_ListAddresses_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_WalletKit_ListAddresses_0(ctx context.Context, marshaler runtime.Marshaler, client WalletKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq ListAddressesRequest
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_ListAddresses_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.ListAddresses(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletKit_ListAddresses_0(ctx context.Context, marshaler runtime.Marshaler, server WalletKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq ListAddressesRequest
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_ListAddresses_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.ListAddresses(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletKit_ImportAccount_0(ctx context.Context, marshaler runtime.Marshaler, client WalletKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq ImportAccountRequest
var metadata runtime.ServerMetadata
@ -951,6 +987,29 @@ func RegisterWalletKitHandlerServer(ctx context.Context, mux *runtime.ServeMux,
})
mux.Handle("GET", pattern_WalletKit_ListAddresses_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/ListAddresses", runtime.WithHTTPPathPattern("/v2/wallet/addresses"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletKit_ListAddresses_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_ListAddresses_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletKit_ImportAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@ -1448,6 +1507,26 @@ func RegisterWalletKitHandlerClient(ctx context.Context, mux *runtime.ServeMux,
})
mux.Handle("GET", pattern_WalletKit_ListAddresses_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/ListAddresses", runtime.WithHTTPPathPattern("/v2/wallet/addresses"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletKit_ListAddresses_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_ListAddresses_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletKit_ImportAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@ -1710,6 +1789,8 @@ var (
pattern_WalletKit_RequiredReserve_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "wallet", "reserve"}, ""))
pattern_WalletKit_ListAddresses_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "wallet", "addresses"}, ""))
pattern_WalletKit_ImportAccount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "wallet", "accounts", "import"}, ""))
pattern_WalletKit_ImportPublicKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "wallet", "key", "import"}, ""))
@ -1754,6 +1835,8 @@ var (
forward_WalletKit_RequiredReserve_0 = runtime.ForwardResponseMessage
forward_WalletKit_ListAddresses_0 = runtime.ForwardResponseMessage
forward_WalletKit_ImportAccount_0 = runtime.ForwardResponseMessage
forward_WalletKit_ImportPublicKey_0 = runtime.ForwardResponseMessage

25
lnrpc/walletrpc/walletkit.pb.json.go
View File

@ -249,6 +249,31 @@ func RegisterWalletKitJSONCallbacks(registry map[string]func(ctx context.Context
callback(string(respBytes), nil)
}
registry["walletrpc.WalletKit.ListAddresses"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &ListAddressesRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewWalletKitClient(conn)
resp, err := client.ListAddresses(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.ImportAccount"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {

75
lnrpc/walletrpc/walletkit.proto
View File

@ -72,6 +72,13 @@ service WalletKit {
rpc RequiredReserve (RequiredReserveRequest)
returns (RequiredReserveResponse);
/*
ListAddresses retrieves all the addresses along with their balance. An
account name filter can be provided to filter through all of the
wallet accounts and return the addresses of only those matching.
*/
rpc ListAddresses (ListAddressesRequest) returns (ListAddressesResponse);
/*
ImportAccount imports an account backed by an account extended public key.
The master key fingerprint denotes the fingerprint of the root key
@ -348,14 +355,7 @@ message Account {
// The name used to identify the account.
string name = 1;
/*
The type of addresses the account supports.
AddressType | External Branch | Internal Branch
---------------------------------------------------------------------
WITNESS_PUBKEY_HASH | P2WPKH | P2WPKH
NESTED_WITNESS_PUBKEY_HASH | NP2WPKH | NP2WPKH
HYBRID_NESTED_WITNESS_PUBKEY_HASH | NP2WPKH | P2WPKH
*/
// The type of addresses the account supports.
AddressType address_type = 2;
/*
@ -397,6 +397,50 @@ message Account {
// Whether the wallet stores private keys for the account.
bool watch_only = 8;
}
message AddressProperty {
/*
The address encoded using the appropriate format depending on the
address type (base58, bech32, bech32m).
Note that lnd's internal/custom keys for channels and other
functionality are derived from the same scope. Since they
aren't really used as addresses and will never have an
on-chain balance, we'll show the public key instead (only if
the show_custom_accounts flag is provided).
*/
string address = 1;
// Denotes if the address is a change address.
bool is_internal = 2;
// The balance of the address.
int64 balance = 3;
}
message AccountWithAddresses {
// The name used to identify the account.
string name = 1;
// The type of addresses the account supports.
AddressType address_type = 2;
/*
The derivation path corresponding to the account public key. This will
always be empty for the default imported account in which single public keys
are imported into.
*/
string derivation_path = 3;
/*
List of address, its type internal/external & balance.
Note that the order of addresses will be random and not according to the
derivation index, since that information is not stored by the underlying
wallet.
*/
repeated AddressProperty addresses = 4;
}
message ListAccountsRequest {
// An optional filter to only return accounts matching this name.
string name = 1;
@ -404,6 +448,7 @@ message ListAccountsRequest {
// An optional filter to only return accounts matching this address type.
AddressType address_type = 2;
}
message ListAccountsResponse {
repeated Account accounts = 1;
}
@ -418,6 +463,20 @@ message RequiredReserveResponse {
int64 required_reserve = 1;
}
message ListAddressesRequest {
// An optional filter to only return addresses matching this account.
string account_name = 1;
// An optional flag to return LND's custom accounts (Purpose=1017)
// public key along with other addresses.
bool show_custom_accounts = 2;
}
message ListAddressesResponse {
// A list of all the accounts and their addresses.
repeated AccountWithAddresses account_with_addresses = 1;
}
message ImportAccountRequest {
// A name to identify the account with.
string name = 1;

95
lnrpc/walletrpc/walletkit.swagger.json
View File

@ -130,6 +130,45 @@
]
}
},
"/v2/wallet/addresses": {
"get": {
"summary": "ListAddresses retrieves all the addresses along with their balance. An\naccount name filter can be provided to filter through all of the\nwallet accounts and return the addresses of only those matching.",
"operationId": "WalletKit_ListAddresses",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/walletrpcListAddressesResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "account_name",
"description": "An optional filter to only return addresses matching this account.",
"in": "query",
"required": false,
"type": "string"
},
{
"name": "show_custom_accounts",
"description": "An optional flag to return LND's custom accounts (Purpose=1017)\npublic key along with other addresses.",
"in": "query",
"required": false,
"type": "boolean"
}
],
"tags": [
"WalletKit"
]
}
},
"/v2/wallet/bumpfee": {
"post": {
"summary": "BumpFee bumps the fee of an arbitrary input within a transaction. This RPC\ntakes a different approach than bitcoind's bumpfee command. lnd has a\ncentral batching engine in which inputs with similar fee rates are batched\ntogether to save on transaction fees. Due to this, we cannot rely on\nbumping the fee on a specific transaction, since transactions can change at\nany point with the addition of new inputs. The list of inputs that\ncurrently exist within lnd's central batching engine can be retrieved\nthrough the PendingSweeps RPC.",
@ -1008,7 +1047,7 @@
},
"address_type": {
"$ref": "#/definitions/walletrpcAddressType",
"title": "The type of addresses the account supports.\nAddressType | External Branch | Internal Branch\n---------------------------------------------------------------------\nWITNESS_PUBKEY_HASH | P2WPKH | P2WPKH\nNESTED_WITNESS_PUBKEY_HASH | NP2WPKH | NP2WPKH\nHYBRID_NESTED_WITNESS_PUBKEY_HASH | NP2WPKH | P2WPKH"
"description": "The type of addresses the account supports."
},
"extended_public_key": {
"type": "string",
@ -1039,6 +1078,30 @@
}
}
},
"walletrpcAccountWithAddresses": {
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "The name used to identify the account."
},
"address_type": {
"$ref": "#/definitions/walletrpcAddressType",
"description": "The type of addresses the account supports."
},
"derivation_path": {
"type": "string",
"description": "The derivation path corresponding to the account public key. This will\nalways be empty for the default imported account in which single public keys\nare imported into."
},
"addresses": {
"type": "array",
"items": {
"$ref": "#/definitions/walletrpcAddressProperty"
},
"description": "List of address, its type internal/external \u0026 balance.\nNote that the order of addresses will be random and not according to the\nderivation index, since that information is not stored by the underlying\nwallet."
}
}
},
"walletrpcAddrRequest": {
"type": "object",
"properties": {
@ -1065,6 +1128,24 @@
}
}
},
"walletrpcAddressProperty": {
"type": "object",
"properties": {
"address": {
"type": "string",
"description": "The address encoded using the appropriate format depending on the\naddress type (base58, bech32, bech32m).\n\nNote that lnd's internal/custom keys for channels and other\nfunctionality are derived from the same scope. Since they\naren't really used as addresses and will never have an\non-chain balance, we'll show the public key instead (only if\nthe show_custom_accounts flag is provided)."
},
"is_internal": {
"type": "boolean",
"description": "Denotes if the address is a change address."
},
"balance": {
"type": "string",
"format": "int64",
"description": "The balance of the address."
}
}
},
"walletrpcAddressType": {
"type": "string",
"enum": [
@ -1347,6 +1428,18 @@
}
}
},
"walletrpcListAddressesResponse": {
"type": "object",
"properties": {
"account_with_addresses": {
"type": "array",
"items": {
"$ref": "#/definitions/walletrpcAccountWithAddresses"
},
"description": "A list of all the accounts and their addresses."
}
}
},
"walletrpcListLeasesResponse": {
"type": "object",
"properties": {

2
lnrpc/walletrpc/walletkit.yaml
View File

@ -57,6 +57,8 @@ http:
get: "/v2/wallet/accounts"
- selector: walletrpc.WalletKit.RequiredReserve
get: "/v2/wallet/reserve"
- selector: walletrpc.WalletKit.ListAddresses
get: "/v2/wallet/addresses"
- selector: walletrpc.WalletKit.ImportAccount
post: "/v2/wallet/accounts/import"
body: "*"

44
lnrpc/walletrpc/walletkit_grpc.pb.go
View File

@ -63,6 +63,11 @@ type WalletKitClient interface {
//scales with the number of public anchor channels but is capped at a maximum.
RequiredReserve(ctx context.Context, in *RequiredReserveRequest, opts ...grpc.CallOption) (*RequiredReserveResponse, error)
//
//ListAddresses retrieves all the addresses along with their balance. An
//account name filter can be provided to filter through all of the
//wallet accounts and return the addresses of only those matching.
ListAddresses(ctx context.Context, in *ListAddressesRequest, opts ...grpc.CallOption) (*ListAddressesResponse, error)
//
//ImportAccount imports an account backed by an account extended public key.
//The master key fingerprint denotes the fingerprint of the root key
//corresponding to the account public key (also known as the key with
@ -295,6 +300,15 @@ func (c *walletKitClient) RequiredReserve(ctx context.Context, in *RequiredReser
return out, nil
}
func (c *walletKitClient) ListAddresses(ctx context.Context, in *ListAddressesRequest, opts ...grpc.CallOption) (*ListAddressesResponse, error) {
out := new(ListAddressesResponse)
err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/ListAddresses", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletKitClient) ImportAccount(ctx context.Context, in *ImportAccountRequest, opts ...grpc.CallOption) (*ImportAccountResponse, error) {
out := new(ImportAccountResponse)
err := c.cc.Invoke(ctx, "/walletrpc.WalletKit/ImportAccount", in, out, opts...)
@ -451,6 +465,11 @@ type WalletKitServer interface {
//scales with the number of public anchor channels but is capped at a maximum.
RequiredReserve(context.Context, *RequiredReserveRequest) (*RequiredReserveResponse, error)
//
//ListAddresses retrieves all the addresses along with their balance. An
//account name filter can be provided to filter through all of the
//wallet accounts and return the addresses of only those matching.
ListAddresses(context.Context, *ListAddressesRequest) (*ListAddressesResponse, error)
//
//ImportAccount imports an account backed by an account extended public key.
//The master key fingerprint denotes the fingerprint of the root key
//corresponding to the account public key (also known as the key with
@ -626,6 +645,9 @@ func (UnimplementedWalletKitServer) ListAccounts(context.Context, *ListAccountsR
func (UnimplementedWalletKitServer) RequiredReserve(context.Context, *RequiredReserveRequest) (*RequiredReserveResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RequiredReserve not implemented")
}
func (UnimplementedWalletKitServer) ListAddresses(context.Context, *ListAddressesRequest) (*ListAddressesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListAddresses not implemented")
}
func (UnimplementedWalletKitServer) ImportAccount(context.Context, *ImportAccountRequest) (*ImportAccountResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ImportAccount not implemented")
}
@ -837,6 +859,24 @@ func _WalletKit_RequiredReserve_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _WalletKit_ListAddresses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListAddressesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletKitServer).ListAddresses(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/walletrpc.WalletKit/ListAddresses",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletKitServer).ListAddresses(ctx, req.(*ListAddressesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletKit_ImportAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ImportAccountRequest)
if err := dec(in); err != nil {
@ -1096,6 +1136,10 @@ var WalletKit_ServiceDesc = grpc.ServiceDesc{
MethodName: "RequiredReserve",
Handler: _WalletKit_RequiredReserve_Handler,
},
{
MethodName: "ListAddresses",
Handler: _WalletKit_ListAddresses_Handler,
},
{
MethodName: "ImportAccount",
Handler: _WalletKit_ImportAccount_Handler,

93
lnrpc/walletrpc/walletkit_server.go
View File

@ -13,6 +13,7 @@ import (
"math"
"os"
"path/filepath"
"sort"
"time"
"github.com/btcsuite/btcd/btcec/v2"
@ -120,6 +121,10 @@ var (
Entity: "onchain",
Action: "read",
}},
"/walletrpc.WalletKit/ListAddresses": {{
Entity: "onchain",
Action: "read",
}},
"/walletrpc.WalletKit/FundPsbt": {{
Entity: "onchain",
Action: "write",
@ -368,6 +373,7 @@ func (w *WalletKit) ListUnspent(ctx context.Context,
utxos, err = w.cfg.Wallet.ListUnspentWitness(
minConfs, maxConfs, req.Account,
)
return err
})
if err != nil {
@ -1416,6 +1422,38 @@ func marshalWalletAccount(internalScope waddrmgr.KeyScope,
return rpcAccount, nil
}
// marshalWalletAddressList converts the list of address into its RPC
// representation.
func marshalWalletAddressList(w *WalletKit, account *waddrmgr.AccountProperties,
addressList []lnwallet.AddressProperty) (*AccountWithAddresses, error) {
// Get the RPC representation of account.
rpcAccount, err := marshalWalletAccount(
w.internalScope(), account,
)
if err != nil {
return nil, err
}
addresses := make([]*AddressProperty, len(addressList))
for idx, addr := range addressList {
addresses[idx] = &AddressProperty{
Address: addr.Address,
IsInternal: addr.Internal,
Balance: int64(addr.Balance),
}
}
rpcAddressList := &AccountWithAddresses{
Name: rpcAccount.Name,
AddressType: rpcAccount.AddressType,
DerivationPath: rpcAccount.DerivationPath,
Addresses: addresses,
}
return rpcAddressList, nil
}
// 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 wallet
// accounts and return only those matching.
@ -1494,6 +1532,61 @@ func (w *WalletKit) RequiredReserve(ctx context.Context,
}, nil
}
// ListAddresses retrieves all the addresses along with their balance. An
// account name filter can be provided to filter through all of the
// wallet accounts and return the addresses of only those matching.
func (w *WalletKit) ListAddresses(ctx context.Context,
req *ListAddressesRequest) (*ListAddressesResponse, error) {
addressLists, err := w.cfg.Wallet.ListAddresses(
req.AccountName,
req.ShowCustomAccounts,
)
if err != nil {
return nil, err
}
// Create a slice of accounts from addressLists map.
accounts := make([]*waddrmgr.AccountProperties, 0, len(addressLists))
for account := range addressLists {
accounts = append(accounts, account)
}
// Sort the accounts by derivation path.
sort.Slice(accounts, func(i, j int) bool {
scopeI := accounts[i].KeyScope
scopeJ := accounts[j].KeyScope
if scopeI.Purpose == scopeJ.Purpose {
if scopeI.Coin == scopeJ.Coin {
acntNumI := accounts[i].AccountNumber
acntNumJ := accounts[j].AccountNumber
return acntNumI < acntNumJ
}
return scopeI.Coin < scopeJ.Coin
}
return scopeI.Purpose < scopeJ.Purpose
})
rpcAddressLists := make([]*AccountWithAddresses, 0, len(addressLists))
for _, account := range accounts {
addressList := addressLists[account]
rpcAddressList, err := marshalWalletAddressList(
w, account, addressList,
)
if err != nil {
return nil, err
}
rpcAddressLists = append(rpcAddressLists, rpcAddressList)
}
return &ListAddressesResponse{
AccountWithAddresses: rpcAddressLists,
}, nil
}
// parseAddrType parses an address type from its RPC representation to a
// *waddrmgr.AddressType.
func parseAddrType(addrType AddressType,

149
lntest/itest/lnd_misc_test.go
View File

@ -4,6 +4,7 @@ import (
"bytes"
"context"
"crypto/rand"
"encoding/hex"
"fmt"
"io/ioutil"
"strings"
@ -1673,3 +1674,151 @@ func testSweepAllCoins(net *lntest.NetworkHarness, t *harnessTest) {
t.Fatalf("sweep attempt should fail")
}
}
// testListAddresses tests that we get all the addresses and their
// corresponding balance correctly.
func testListAddresses(net *lntest.NetworkHarness, t *harnessTest) {
ctxb := context.Background()
// First, we'll make a new node - Alice, which will be generating
// new addresses.
alice := net.NewNode(t.t, "Alice", nil)
defer shutdownAndAssert(net, t, alice)
// Next, we'll give Alice exactly 1 utxo of 1 BTC.
net.SendCoins(t.t, btcutil.SatoshiPerBitcoin, alice)
type addressDetails struct {
Balance int64
Type walletrpc.AddressType
}
// A map of generated address and its balance.
generatedAddr := make(map[string]addressDetails)
// Create an address generated from internal keys.
keyLoc := &walletrpc.KeyReq{KeyFamily: 123}
keyDesc, err := alice.WalletKitClient.DeriveNextKey(ctxb, keyLoc)
require.NoError(t.t, err)
// Hex Encode the public key.
pubkeyString := hex.EncodeToString(keyDesc.RawKeyBytes)
// Create a p2tr address.
resp, err := alice.NewAddress(ctxb, &lnrpc.NewAddressRequest{
Type: lnrpc.AddressType_TAPROOT_PUBKEY,
})
require.NoError(t.t, err)
generatedAddr[resp.Address] = addressDetails{
Balance: 200_000,
Type: walletrpc.AddressType_TAPROOT_PUBKEY,
}
// Create a p2wkh address.
resp, err = alice.NewAddress(ctxb, &lnrpc.NewAddressRequest{
Type: lnrpc.AddressType_WITNESS_PUBKEY_HASH,
})
require.NoError(t.t, err)
generatedAddr[resp.Address] = addressDetails{
Balance: 300_000,
Type: walletrpc.AddressType_WITNESS_PUBKEY_HASH,
}
// Create a np2wkh address.
resp, err = alice.NewAddress(ctxb, &lnrpc.NewAddressRequest{
Type: lnrpc.AddressType_NESTED_PUBKEY_HASH,
})
require.NoError(t.t, err)
generatedAddr[resp.Address] = addressDetails{
Balance: 400_000,
Type: walletrpc.AddressType_HYBRID_NESTED_WITNESS_PUBKEY_HASH,
}
for addr, addressDetail := range generatedAddr {
_, err := alice.SendCoins(ctxb, &lnrpc.SendCoinsRequest{
Addr: addr,
Amount: addressDetail.Balance,
SpendUnconfirmed: true,
})
require.NoError(t.t, err)
}
mineBlocks(t, net, 1, 3)
// Get all the accounts except LND's custom accounts.
addressLists, err := alice.WalletKitClient.ListAddresses(
ctxb, &walletrpc.ListAddressesRequest{},
)
require.NoError(t.t, err)
foundAddresses := 0
for _, addressList := range addressLists.AccountWithAddresses {
addresses := addressList.Addresses
derivationPath, err := parseDerivationPath(
addressList.DerivationPath,
)
require.NoError(t.t, err)
// Should not get an account with KeyFamily - 123.
require.NotEqual(
t.t, uint32(keyLoc.KeyFamily), derivationPath[2],
)
for _, address := range addresses {
if _, ok := generatedAddr[address.Address]; ok {
addrDetails := generatedAddr[address.Address]
require.Equal(
t.t, addrDetails.Balance,
address.Balance,
)
require.Equal(
t.t, addrDetails.Type,
addressList.AddressType,
)
foundAddresses++
}
}
}
require.Equal(t.t, len(generatedAddr), foundAddresses)
foundAddresses = 0
// Get all the accounts (including LND's custom accounts).
addressLists, err = alice.WalletKitClient.ListAddresses(
ctxb, &walletrpc.ListAddressesRequest{
ShowCustomAccounts: true,
},
)
require.NoError(t.t, err)
for _, addressList := range addressLists.AccountWithAddresses {
addresses := addressList.Addresses
derivationPath, err := parseDerivationPath(
addressList.DerivationPath,
)
require.NoError(t.t, err)
for _, address := range addresses {
// Check if the KeyFamily in derivation path is 123.
if uint32(keyLoc.KeyFamily) == derivationPath[2] {
// For LND's custom accounts, the address
// represents the public key.
pubkey := address.Address
require.Equal(t.t, pubkeyString, pubkey)
} else if _, ok := generatedAddr[address.Address]; ok {
addrDetails := generatedAddr[address.Address]
require.Equal(
t.t, addrDetails.Balance,
address.Balance,
)
require.Equal(
t.t, addrDetails.Type,
addressList.AddressType,
)
foundAddresses++
}
}
}
require.Equal(t.t, len(generatedAddr), foundAddresses)
}

4
lntest/itest/lnd_test_list_on_test.go
View File

@ -12,6 +12,10 @@ var allTestCases = []*testCase{
name: "sweep coins",
test: testSweepAllCoins,
},
{
name: "list addresses",
test: testListAddresses,
},
{
name: "recovery info",
test: testGetRecoveryInfo,

38
lntest/itest/utils.go
View File

@ -5,6 +5,8 @@ import (
"crypto/rand"
"fmt"
"io"
"strconv"
"strings"
"time"
"github.com/btcsuite/btcd/btcutil"
@ -494,6 +496,42 @@ func getOutputIndex(t *harnessTest, miner *lntest.HarnessMiner,
return p2trOutputIndex
}
// parseDerivationPath parses a path in the form of m/x'/y'/z'/a/b into a slice
// of [x, y, z, a, b], meaning that the apostrophe is ignored and 2^31 is _not_
// added to the numbers.
func parseDerivationPath(path string) ([]uint32, error) {
path = strings.TrimSpace(path)
if len(path) == 0 {
return nil, fmt.Errorf("path cannot be empty")
}
if !strings.HasPrefix(path, "m/") {
return nil, fmt.Errorf("path must start with m/")
}
// Just the root key, no path was provided. This is valid but not useful
// in most cases.
rest := strings.ReplaceAll(path, "m/", "")
if rest == "" {
return []uint32{}, nil
}
parts := strings.Split(rest, "/")
indices := make([]uint32, len(parts))
for i := 0; i < len(parts); i++ {
part := parts[i]
if strings.Contains(parts[i], "'") {
part = strings.TrimRight(parts[i], "'")
}
parsed, err := strconv.ParseInt(part, 10, 32)
if err != nil {
return nil, fmt.Errorf("could not parse part \"%s\": "+
"%v", part, err)
}
indices[i] = uint32(parsed)
}
return indices, nil
}
// acceptChannel is used to accept a single channel that comes across. This
// should be run in a goroutine and is used to test nodes with the zero-conf
// feature bit.

7
lntest/mock/walletcontroller.go
View File

@ -110,6 +110,13 @@ func (w *WalletController) RequiredReserve(uint32) btcutil.Amount {
return 0
}
// ListAddresses currently returns a dummy value.
func (w *WalletController) ListAddresses(string,
bool) (lnwallet.AccountAddressMap, error) {
return nil, nil
}
// ImportAccount currently returns a dummy value.
func (w *WalletController) ImportAccount(string, *hdkeychain.ExtendedKey,
uint32, *waddrmgr.AddressType, bool) (*waddrmgr.AccountProperties,

106
lnwallet/btcwallet/btcwallet.go
View File

@ -706,6 +706,112 @@ func (b *BtcWallet) RequiredReserve(
return reserved
}
// ListAddresses retrieves all the addresses along with their balance. An
// account name filter can be provided to filter through all of the
// wallet accounts and return the addresses of only those matching.
//
// This is a part of the WalletController interface.
func (b *BtcWallet) ListAddresses(name string,
showCustomAccounts bool) (lnwallet.AccountAddressMap, error) {
accounts, err := b.ListAccounts(name, nil)
if err != nil {
return nil, err
}
addresses := make(lnwallet.AccountAddressMap)
addressBalance := make(map[string]btcutil.Amount)
// Retrieve all the unspent ouputs.
outputs, err := b.wallet.ListUnspent(0, math.MaxInt32, "")
if err != nil {
return nil, err
}
// Calculate the total balance of each address.
for _, output := range outputs {
amount, err := btcutil.NewAmount(output.Amount)
if err != nil {
return nil, err
}
addressBalance[output.Address] += amount
}
for _, accntDetails := range accounts {
accntScope := accntDetails.KeyScope
scopedMgr, err := b.wallet.Manager.FetchScopedKeyManager(
accntScope,
)
if err != nil {
return nil, err
}
var managedAddrs []waddrmgr.ManagedAddress
err = walletdb.View(
b.wallet.Database(), func(tx walletdb.ReadTx) error {
managedAddrs = nil
addrmgrNs := tx.ReadBucket(waddrmgrNamespaceKey)
return scopedMgr.ForEachAccountAddress(
addrmgrNs, accntDetails.AccountNumber,
func(a waddrmgr.ManagedAddress) error {
managedAddrs = append(
managedAddrs, a,
)
return nil
},
)
},
)
if err != nil {
return nil, err
}
// Only consider those accounts which have addresses.
if len(managedAddrs) == 0 {
continue
}
// All the lnd internal/custom keys for channels and other
// functionality are derived from the same scope. Since they
// aren't really used as addresses and will never have an
// on-chain balance, we'll want to show the public key instead.
isLndCustom := accntScope.Purpose == keychain.BIP0043Purpose
addressProperties := make(
[]lnwallet.AddressProperty, len(managedAddrs),
)
for idx, managedAddr := range managedAddrs {
addr := managedAddr.Address()
addressString := addr.String()
// Hex-encode the compressed public key for custom lnd
// keys, addresses don't make a lot of sense.
pubKey, ok := managedAddr.(waddrmgr.ManagedPubKeyAddress)
if ok && isLndCustom {
addressString = hex.EncodeToString(
pubKey.PubKey().SerializeCompressed(),
)
}
addressProperties[idx] = lnwallet.AddressProperty{
Address: addressString,
Internal: managedAddr.Internal(),
Balance: addressBalance[addressString],
}
}
if accntScope.Purpose != keychain.BIP0043Purpose ||
showCustomAccounts {
addresses[accntDetails] = addressProperties
}
}
return addresses, nil
}
// ImportAccount imports an account backed by an account extended public key.
// The master key fingerprint denotes the fingerprint of the root key
// corresponding to the account public key (also known as the key with

34
lnwallet/interface.go
View File

@ -32,6 +32,10 @@ const (
// WalletController supports.
type AddressType uint8
// AccountAddressMap maps the account properties to an array of
// address properties.
type AccountAddressMap map[*waddrmgr.AccountProperties][]AddressProperty
const (
// UnknownAddressType represents an output with an unknown or non-standard
// script.
@ -76,6 +80,31 @@ var ErrNoOutputs = errors.New("no outputs")
var ErrInvalidMinconf = errors.New("minimum number of confirmations must " +
"be a non-negative number")
// AddressProperty contains wallet related information of an address.
type AddressProperty struct {
// Address is the address of an account.
Address string
// Internal denotes if the address is a change address.
Internal bool
// Balance returns the total balance of an address.
Balance btcutil.Amount
}
// AccountIdentifier contains information to uniquely identify an account.
type AccountIdentifier struct {
// Name is the name of the account.
Name string
// AddressType is the type of addresses supported by the account.
AddressType AddressType
// DerivationPath is the derivation path corresponding to the account
// public key.
DerivationPath string
}
// Utxo is an unspent output denoted by its outpoint, and output value of the
// original output.
type Utxo struct {
@ -250,6 +279,11 @@ type WalletController interface {
// capped at a maximum.
RequiredReserve(uint32) btcutil.Amount
// ListAddresses retrieves all the addresses along with their balance. An
// account name filter can be provided to filter through all of the
// wallet accounts and return the addresses of only those matching.
ListAddresses(string, bool) (AccountAddressMap, error)
// ImportAccount imports an account backed by an account extended public
// key. The master key fingerprint denotes the fingerprint of the root
// key corresponding to the account public key (also known as the key