mleku
a7dd958585
* Renamed `NWCClient` to `nwc.NewNWCClient(opts)` in `cmd/nwcclient/main.go`
* Added `RPCRaw` wrappers for NWC client methods in `pkg/protocol/nwc/methods.go`
**Updated walletcli main function**
* Updated the main function in `cmd/walletcli/main.go` to use new NWC client and RPCRaw wrappers
**Added new methods for walletcli**
* Added new methods for handling NWC client RPC calls, such as:
* `handleGetWalletServiceInfo`
* `handleMakeHoldInvoice`
* `handleSettleHoldInvoice`
* `handleCancelHoldInvoice`
**Code formatting and style changes**
* Formatted code according to Go standard
* Used consistent naming conventions and coding styles
**Other updates**
* Updated dependencies and imported packages accordingly
512 lines
12 KiB
Go
512 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"orly.dev/pkg/protocol/nwc"
|
|
"orly.dev/pkg/utils/context"
|
|
)
|
|
|
|
func printUsage() {
|
|
fmt.Println("Usage: walletcli '<NWC connection URL>' <method> [<args...>]")
|
|
fmt.Println("\nAvailable methods:")
|
|
fmt.Println(" get_wallet_service_info - Get wallet service information")
|
|
fmt.Println(" get_info - Get wallet information")
|
|
fmt.Println(" get_balance - Get wallet balance")
|
|
fmt.Println(" get_budget - Get wallet budget")
|
|
fmt.Println(" make_invoice - Create an invoice")
|
|
fmt.Println(" Args: <amount> [<description>] [<description_hash>] [<expiry>]")
|
|
fmt.Println(" pay_invoice - Pay an invoice")
|
|
fmt.Println(" Args: <invoice> [<amount>] [<comment>]")
|
|
fmt.Println(" pay_keysend - Pay to a node using keysend")
|
|
fmt.Println(" Args: <pubkey> <amount> [<preimage>] [<tlv_type> <tlv_value>...]")
|
|
fmt.Println(" lookup_invoice - Look up an invoice")
|
|
fmt.Println(" Args: <payment_hash or invoice>")
|
|
fmt.Println(" list_transactions - List transactions")
|
|
fmt.Println(" Args: [<limit>] [<offset>] [<from>] [<until>]")
|
|
fmt.Println(" make_hold_invoice - Create a hold invoice")
|
|
fmt.Println(" Args: <amount> <payment_hash> [<description>] [<description_hash>] [<expiry>]")
|
|
fmt.Println(" settle_hold_invoice - Settle a hold invoice")
|
|
fmt.Println(" Args: <preimage>")
|
|
fmt.Println(" cancel_hold_invoice - Cancel a hold invoice")
|
|
fmt.Println(" Args: <payment_hash>")
|
|
fmt.Println(" sign_message - Sign a message")
|
|
fmt.Println(" Args: <message>")
|
|
fmt.Println(" create_connection - Create a connection")
|
|
fmt.Println(" Args: <pubkey> <name> <methods> [<notification_types>] [<max_amount>] [<budget_renewal>] [<expires_at>]")
|
|
}
|
|
|
|
func main() {
|
|
if len(os.Args) < 3 {
|
|
printUsage()
|
|
os.Exit(1)
|
|
}
|
|
|
|
connectionURL := os.Args[1]
|
|
method := os.Args[2]
|
|
args := os.Args[3:]
|
|
|
|
// Create context
|
|
ctx := context.Bg()
|
|
|
|
// Create NWC client
|
|
client, err := nwc.NewClient(ctx, connectionURL)
|
|
if err != nil {
|
|
fmt.Printf("Error creating client: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Execute the requested method
|
|
switch method {
|
|
case "get_wallet_service_info":
|
|
handleGetWalletServiceInfo(ctx, client)
|
|
case "get_info":
|
|
handleGetInfo(ctx, client)
|
|
case "get_balance":
|
|
handleGetBalance(ctx, client)
|
|
case "get_budget":
|
|
handleGetBudget(ctx, client)
|
|
case "make_invoice":
|
|
handleMakeInvoice(ctx, client, args)
|
|
case "pay_invoice":
|
|
handlePayInvoice(ctx, client, args)
|
|
case "pay_keysend":
|
|
handlePayKeysend(ctx, client, args)
|
|
case "lookup_invoice":
|
|
handleLookupInvoice(ctx, client, args)
|
|
case "list_transactions":
|
|
handleListTransactions(ctx, client, args)
|
|
case "make_hold_invoice":
|
|
handleMakeHoldInvoice(ctx, client, args)
|
|
case "settle_hold_invoice":
|
|
handleSettleHoldInvoice(ctx, client, args)
|
|
case "cancel_hold_invoice":
|
|
handleCancelHoldInvoice(ctx, client, args)
|
|
case "sign_message":
|
|
handleSignMessage(ctx, client, args)
|
|
case "create_connection":
|
|
handleCreateConnection(ctx, client, args)
|
|
default:
|
|
fmt.Printf("Unknown method: %s\n", method)
|
|
printUsage()
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func handleGetWalletServiceInfo(ctx context.T, client *nwc.Client) {
|
|
raw, err := client.GetWalletServiceInfoRaw(ctx)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleGetInfo(ctx context.T, client *nwc.Client) {
|
|
raw, err := client.GetInfoRaw(ctx)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleGetBalance(ctx context.T, client *nwc.Client) {
|
|
raw, err := client.GetBalanceRaw(ctx)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleGetBudget(ctx context.T, client *nwc.Client) {
|
|
raw, err := client.GetBudgetRaw(ctx)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleMakeInvoice(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 1 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> make_invoice <amount> [<description>] [<description_hash>] [<expiry>]")
|
|
return
|
|
}
|
|
|
|
amount, err := strconv.ParseUint(args[0], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing amount: %v\n", err)
|
|
return
|
|
}
|
|
|
|
params := &nwc.MakeInvoiceParams{
|
|
Amount: amount,
|
|
}
|
|
|
|
if len(args) > 1 {
|
|
params.Description = args[1]
|
|
}
|
|
|
|
if len(args) > 2 {
|
|
params.DescriptionHash = args[2]
|
|
}
|
|
|
|
if len(args) > 3 {
|
|
expiry, err := strconv.ParseInt(args[3], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing expiry: %v\n", err)
|
|
return
|
|
}
|
|
params.Expiry = &expiry
|
|
}
|
|
|
|
raw, err := client.MakeInvoiceRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handlePayInvoice(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 1 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> pay_invoice <invoice> [<amount>] [<comment>]")
|
|
return
|
|
}
|
|
|
|
params := &nwc.PayInvoiceParams{
|
|
Invoice: args[0],
|
|
}
|
|
|
|
if len(args) > 1 {
|
|
amount, err := strconv.ParseUint(args[1], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing amount: %v\n", err)
|
|
return
|
|
}
|
|
params.Amount = &amount
|
|
}
|
|
|
|
if len(args) > 2 {
|
|
comment := args[2]
|
|
params.Metadata = &nwc.PayInvoiceMetadata{
|
|
Comment: &comment,
|
|
}
|
|
}
|
|
|
|
raw, err := client.PayInvoiceRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleLookupInvoice(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 1 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> lookup_invoice <payment_hash or invoice>")
|
|
return
|
|
}
|
|
|
|
params := &nwc.LookupInvoiceParams{}
|
|
|
|
// Determine if the argument is a payment hash or an invoice
|
|
if strings.HasPrefix(args[0], "ln") {
|
|
invoice := args[0]
|
|
params.Invoice = &invoice
|
|
} else {
|
|
paymentHash := args[0]
|
|
params.PaymentHash = &paymentHash
|
|
}
|
|
|
|
raw, err := client.LookupInvoiceRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleListTransactions(ctx context.T, client *nwc.Client, args []string) {
|
|
params := &nwc.ListTransactionsParams{}
|
|
|
|
if len(args) > 0 {
|
|
limit, err := strconv.ParseUint(args[0], 10, 16)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing limit: %v\n", err)
|
|
return
|
|
}
|
|
limitUint16 := uint16(limit)
|
|
params.Limit = &limitUint16
|
|
}
|
|
|
|
if len(args) > 1 {
|
|
offset, err := strconv.ParseUint(args[1], 10, 32)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing offset: %v\n", err)
|
|
return
|
|
}
|
|
offsetUint32 := uint32(offset)
|
|
params.Offset = &offsetUint32
|
|
}
|
|
|
|
if len(args) > 2 {
|
|
from, err := strconv.ParseInt(args[2], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing from: %v\n", err)
|
|
return
|
|
}
|
|
params.From = &from
|
|
}
|
|
|
|
if len(args) > 3 {
|
|
until, err := strconv.ParseInt(args[3], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing until: %v\n", err)
|
|
return
|
|
}
|
|
params.Until = &until
|
|
}
|
|
|
|
raw, err := client.ListTransactionsRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleMakeHoldInvoice(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 2 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> make_hold_invoice <amount> <payment_hash> [<description>] [<description_hash>] [<expiry>]")
|
|
return
|
|
}
|
|
|
|
amount, err := strconv.ParseUint(args[0], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing amount: %v\n", err)
|
|
return
|
|
}
|
|
|
|
params := &nwc.MakeHoldInvoiceParams{
|
|
Amount: amount,
|
|
PaymentHash: args[1],
|
|
}
|
|
|
|
if len(args) > 2 {
|
|
params.Description = args[2]
|
|
}
|
|
|
|
if len(args) > 3 {
|
|
params.DescriptionHash = args[3]
|
|
}
|
|
|
|
if len(args) > 4 {
|
|
expiry, err := strconv.ParseInt(args[4], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing expiry: %v\n", err)
|
|
return
|
|
}
|
|
params.Expiry = &expiry
|
|
}
|
|
|
|
raw, err := client.MakeHoldInvoiceRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleSettleHoldInvoice(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 1 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> settle_hold_invoice <preimage>")
|
|
return
|
|
}
|
|
|
|
params := &nwc.SettleHoldInvoiceParams{
|
|
Preimage: args[0],
|
|
}
|
|
|
|
raw, err := client.SettleHoldInvoiceRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleCancelHoldInvoice(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 1 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> cancel_hold_invoice <payment_hash>")
|
|
return
|
|
}
|
|
|
|
params := &nwc.CancelHoldInvoiceParams{
|
|
PaymentHash: args[0],
|
|
}
|
|
|
|
raw, err := client.CancelHoldInvoiceRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleSignMessage(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 1 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> sign_message <message>")
|
|
return
|
|
}
|
|
|
|
params := &nwc.SignMessageParams{
|
|
Message: args[0],
|
|
}
|
|
|
|
raw, err := client.SignMessageRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handlePayKeysend(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 2 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> pay_keysend <pubkey> <amount> [<preimage>] [<tlv_type> <tlv_value>...]")
|
|
return
|
|
}
|
|
|
|
pubkey := args[0]
|
|
|
|
amount, err := strconv.ParseUint(args[1], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing amount: %v\n", err)
|
|
return
|
|
}
|
|
|
|
params := &nwc.PayKeysendParams{
|
|
Pubkey: pubkey,
|
|
Amount: amount,
|
|
}
|
|
|
|
// Optional preimage
|
|
if len(args) > 2 {
|
|
preimage := args[2]
|
|
params.Preimage = &preimage
|
|
}
|
|
|
|
// Optional TLV records (must come in pairs)
|
|
if len(args) > 3 {
|
|
// Start from index 3 and process pairs of arguments
|
|
for i := 3; i < len(args)-1; i += 2 {
|
|
tlvType, err := strconv.ParseUint(args[i], 10, 32)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing TLV type: %v\n", err)
|
|
return
|
|
}
|
|
|
|
tlvValue := args[i+1]
|
|
|
|
params.TLVRecords = append(
|
|
params.TLVRecords, nwc.PayKeysendTLVRecord{
|
|
Type: uint32(tlvType),
|
|
Value: tlvValue,
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
raw, err := client.PayKeysendRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func handleCreateConnection(ctx context.T, client *nwc.Client, args []string) {
|
|
if len(args) < 3 {
|
|
fmt.Println("Error: Missing required arguments")
|
|
fmt.Println("Usage: walletcli <NWC connection URL> create_connection <pubkey> <name> <methods> [<notification_types>] [<max_amount>] [<budget_renewal>] [<expires_at>]")
|
|
return
|
|
}
|
|
|
|
params := &nwc.CreateConnectionParams{
|
|
Pubkey: args[0],
|
|
Name: args[1],
|
|
RequestMethods: strings.Split(args[2], ","),
|
|
}
|
|
|
|
if len(args) > 3 {
|
|
params.NotificationTypes = strings.Split(args[3], ",")
|
|
}
|
|
|
|
if len(args) > 4 {
|
|
maxAmount, err := strconv.ParseUint(args[4], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing max_amount: %v\n", err)
|
|
return
|
|
}
|
|
params.MaxAmount = &maxAmount
|
|
}
|
|
|
|
if len(args) > 5 {
|
|
params.BudgetRenewal = &args[5]
|
|
}
|
|
|
|
if len(args) > 6 {
|
|
expiresAt, err := strconv.ParseInt(args[6], 10, 64)
|
|
if err != nil {
|
|
fmt.Printf("Error parsing expires_at: %v\n", err)
|
|
return
|
|
}
|
|
params.ExpiresAt = &expiresAt
|
|
}
|
|
|
|
raw, err := client.CreateConnectionRaw(ctx, params)
|
|
if err != nil {
|
|
fmt.Printf("Error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(raw))
|
|
}
|
|
|
|
func printJSON(v interface{}) {
|
|
data, err := json.MarshalIndent(v, "", " ")
|
|
if err != nil {
|
|
fmt.Printf("Error marshaling JSON: %v\n", err)
|
|
return
|
|
}
|
|
fmt.Println(string(data))
|
|
}
|