[bug]: rpc error: code = Unknown desc = expected 1 macaroon, got 0

[lenhatquang97]

Background

I want to use LND API from Golang for setup like in this tutorial: https://medium.com/hackernoon/learning-bitcoins-lightning-network-with-go-set-up-deea944b920e
However it shows an error for no macaroon.

Your environment

• version of lnd
  lnd: 0.15.99-beta commit=cert/v1.2.0-6-g22fec7633
  OS: Ubuntu 22.04.1 LTS
  Btcd version: 0.23.3-beta

Steps to reproduce

1. Connect btcd on terminal
2. Connect lnd and lncli unlock
3. After connecting, I run this code on Golang: https://pastebin.com/38PuPpgt

Tell us how to reproduce this issue. Please provide stacktraces and links to code in question.

Expected behaviour

This code shows wallet balance.

Actual behaviour

rpc error: code = Unknown desc = expected 1 macaroon, got 0

[ellemouton]

Hi @lenhatquang97 ,

The first thing that jumps out to me when looking at your connection code is this:

// Macaroon setup
macaroonFileLocation := fmt.Sprintf("%s/data/chain/bitcoin/testnet/admin.macaroon", lndDir)
macaroonMap := map[string]string{"macaroon": macaroonFileLocation}
macaroonMetadata := metadata.New(macaroonMap)
MACAROONOPTION = grpc.Header(&macaroonMetadata)

From this, it looks like you are using the path to your macaroon file as the actual macaroon text instead of first reading in the content of the macaroon file.

For a simple example of how to read from a macaroon file and include that in your call, see how it is done here

[lenhatquang97]

I try to get function readMacaroon in my source code, however it shows below:
github.com/lightningnetwork/lnd/macaroons: module github.com/lightningnetwork/lnd@latest found (v0.0.2), but does not contain package github.com/lightningnetwork/lnd/macaroons

How can I import macaroons to my source code?

[guggero]

Unfortunately there was an ancient version (v0.0.2) published without the -beta suffix. So if you don't specify an explicit version, the Golang module system ends up picking that one, which is many many years old.
You can fix that by specifying a specific tagged version in your go.mod file. For example v0.15.5-beta.

[lenhatquang97]

readMacaroon function works well, but I wanna know how to use lncli.WalletBalance with call option

Description in WalletBalance function:
func (lnrpc.LightningClient).WalletBalance(ctx context.Context, in *lnrpc.WalletBalanceRequest, opts ...grpc.CallOption) (*lnrpc.WalletBalanceResponse, error)
lncli: walletbalance WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and all unconfirmed unspent outputs under control of the wallet.

[guggero]

You could use lndclient's NewBasicConn() function, which then gives you a connection that has the macaroon always applied to it (for each request).
If you use such a connection, you can then go ahead and call client := lnrpc.NewLightningClient(grpcConnection). And because the macaroon is always attached automatically, you don't need to specify any call options when then calling into client.WalletBalance() (only the context and the request message).

You can also take a look at how lncli calls the RPC: https://github.com/lightningnetwork/lnd/blob/master/cmd/lncli/commands.go#L1294

[lenhatquang97]

Thank everyone so much. I have retrieved my wallet balance!!!
My sample code below here:

package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"os/user"
	"time"

	"github.com/lightningnetwork/lnd/lnrpc"
	"github.com/lightningnetwork/lnd/macaroons"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"gopkg.in/macaroon.v2"
)

var maxMsgRecvSize = grpc.MaxCallRecvMsgSize(1 * 1024 * 1024 * 200)

func grpcSetup() *grpc.ClientConn {
	usr, err := user.Current()
	if err != nil {
		log.Fatal(err)
	}
	homeDir := usr.HomeDir
	lndDir := homeDir + "/.lnd"
	macaroonFileLocation := fmt.Sprintf("%s/data/chain/bitcoin/testnet/admin.macaroon", lndDir)
	tlsCertPath := fmt.Sprintf("%s/tls.cert", lndDir)
	macOption, err := readMacaroon(macaroonFileLocation)
	if err != nil {
		return nil
	}

	opts := []grpc.DialOption{
		grpc.WithDefaultCallOptions(maxMsgRecvSize),
		macOption,
	}

	// TLS cannot be disabled, we'll always have a cert file to read.
	creds, _ := credentials.NewClientTLSFromFile(tlsCertPath, "")
	opts = append(opts, grpc.WithTransportCredentials(creds))
	conn, err := grpc.Dial("localhost:10009", opts...)
	if err != nil {
		return nil
	}

	return conn
}

func readMacaroon(macPath string) (grpc.DialOption, error) {
	// Load the specified macaroon file.
	macBytes, err := ioutil.ReadFile(macPath)
	if err != nil {
		return nil, fmt.Errorf("unable to read macaroon path : %v", err)
	}

	mac := &macaroon.Macaroon{}
	if err = mac.UnmarshalBinary(macBytes); err != nil {
		return nil, fmt.Errorf("unable to decode macaroon: %v", err)
	}

	macConstraints := []macaroons.Constraint{
		// We add a time-based constraint to prevent replay of the
		// macaroon. It's good for 60 seconds by default to make up for
		// any discrepancy between client and server clocks, but leaking
		// the macaroon before it becomes invalid makes it possible for
		// an attacker to reuse the macaroon. In addition, the validity
		// time of the macaroon is extended by the time the server clock
		// is behind the client clock, or shortened by the time the
		// server clock is ahead of the client clock (or invalid
		// altogether if, in the latter case, this time is more than 60
		// seconds).
		macaroons.TimeoutConstraint(60),
	}

	// Apply constraints to the macaroon.
	constrainedMac, err := macaroons.AddConstraints(mac, macConstraints...)
	if err != nil {
		return nil, err
	}

	// Now we append the macaroon credentials to the dial options.
	cred, err := macaroons.NewMacaroonCredential(constrainedMac)
	if err != nil {
		return nil, fmt.Errorf("error creating macaroon credential: %v",
			err)
	}
	return grpc.WithPerRPCCredentials(cred), nil
}

func main() {
	grpcConn := grpcSetup()
	defer grpcConn.Close()

	lncli := lnrpc.NewLightningClient(grpcConn)
	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
	walletBalanceReq := lnrpc.WalletBalanceRequest{}
	walletRes, err := lncli.WalletBalance(ctx, &walletBalanceReq)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(walletRes.TotalBalance)
	}

}