--prompt-sec for getting a secret key from a prompt.

README.md

@@ -76,3 +76,8 @@ publishing to wss://relayable.org... success.
 ~> echo '{"content":"hello world","created_at":1698923350,"id":"05bd99d54cb835f327e0092c4275ee44c7ff51219eff417c19f70c9e2c53ad5a","kind":1,"pubkey":"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798","sig":"0a04a296321ed933858577f36fb2fb9a0933e966f9ee32b539493f5a4d00120891b1ca9152ebfbc04fb403bdaa7c73f415e7c4954e55726b4b4fa8cebf008cd6","tags":[]}' | nak verify
 invalid .id, expected 05bd99d54cb835f427e0092c4275ee44c7ff51219eff417c19f70c9e2c53ad5a, got 05bd99d54cb835f327e0092c4275ee44c7ff51219eff417c19f70c9e2c53ad5a
 ```
+
+### fetch all quoted events by a given pubkey in their last 100 notes
+```shell
+nak req -l 100 -k 1 -a 2edbcea694d164629854a52583458fd6d965b161e3c48b57d3aff01940558884 wss://relay.damus.io | jq -r '.content | match("nostr:((note1|nevent1)[a-z0-9]+)";"g") | .captures[0].string' | nak decode | jq -cr '{ids: [.id]}' | nak req wss://relay.damus.io
+```

decode.go

@@ -34,43 +34,45 @@ var decode = &cli.Command{
 	},
 	ArgsUsage: "<npub | nprofile | nip05 | nevent | naddr | nsec>",
 	Action: func(c *cli.Context) error {
-		args := c.Args()
+		for input := range getStdinLinesOrFirstArgument(c) {
-		if args.Len() != 1 {
+			if strings.HasPrefix(input, "nostr:") {
-			return fmt.Errorf("invalid number of arguments, need just one")
+				input = input[6:]
-		}
-		input := args.First()
-		if strings.HasPrefix(input, "nostr:") {
-			input = input[6:]
-		}
-
-		var decodeResult DecodeResult
-		if b, err := hex.DecodeString(input); err == nil {
-			if len(b) == 64 {
-				decodeResult.HexResult.PossibleTypes = []string{"sig"}
-				decodeResult.HexResult.Signature = hex.EncodeToString(b)
-			} else if len(b) == 32 {
-				decodeResult.HexResult.PossibleTypes = []string{"pubkey", "private_key", "event_id"}
-				decodeResult.HexResult.ID = hex.EncodeToString(b)
-				decodeResult.HexResult.PrivateKey = hex.EncodeToString(b)
-				decodeResult.HexResult.PublicKey = hex.EncodeToString(b)
-			} else {
-				return fmt.Errorf("hex string with invalid number of bytes: %d", len(b))
 			}
-		} else if evp := sdk.InputToEventPointer(input); evp != nil {
+
-			decodeResult = DecodeResult{EventPointer: evp}
+			var decodeResult DecodeResult
-		} else if pp := sdk.InputToProfile(c.Context, input); pp != nil {
+			if b, err := hex.DecodeString(input); err == nil {
-			decodeResult = DecodeResult{ProfilePointer: pp}
+				if len(b) == 64 {
-		} else if prefix, value, err := nip19.Decode(input); err == nil && prefix == "naddr" {
+					decodeResult.HexResult.PossibleTypes = []string{"sig"}
-			ep := value.(nostr.EntityPointer)
+					decodeResult.HexResult.Signature = hex.EncodeToString(b)
-			decodeResult = DecodeResult{EntityPointer: &ep}
+				} else if len(b) == 32 {
-		} else if prefix, value, err := nip19.Decode(input); err == nil && prefix == "nsec" {
+					decodeResult.HexResult.PossibleTypes = []string{"pubkey", "private_key", "event_id"}
-			decodeResult.PrivateKey.PrivateKey = value.(string)
+					decodeResult.HexResult.ID = hex.EncodeToString(b)
-			decodeResult.PrivateKey.PublicKey, _ = nostr.GetPublicKey(value.(string))
+					decodeResult.HexResult.PrivateKey = hex.EncodeToString(b)
-		} else {
+					decodeResult.HexResult.PublicKey = hex.EncodeToString(b)
-			return fmt.Errorf("couldn't decode input")
+				} else {
+					lineProcessingError(c, "hex string with invalid number of bytes: %d", len(b))
+					continue
+				}
+			} else if evp := sdk.InputToEventPointer(input); evp != nil {
+				decodeResult = DecodeResult{EventPointer: evp}
+			} else if pp := sdk.InputToProfile(c.Context, input); pp != nil {
+				decodeResult = DecodeResult{ProfilePointer: pp}
+			} else if prefix, value, err := nip19.Decode(input); err == nil && prefix == "naddr" {
+				ep := value.(nostr.EntityPointer)
+				decodeResult = DecodeResult{EntityPointer: &ep}
+			} else if prefix, value, err := nip19.Decode(input); err == nil && prefix == "nsec" {
+				decodeResult.PrivateKey.PrivateKey = value.(string)
+				decodeResult.PrivateKey.PublicKey, _ = nostr.GetPublicKey(value.(string))
+			} else {
+				lineProcessingError(c, "couldn't decode input '%s': %s", input, err)
+				continue
+			}
+
+			fmt.Println(decodeResult.JSON())
+
 		}
 
-		fmt.Println(decodeResult.JSON())
+		exitIfLineProcessingError(c)
 		return nil
 	},
 }

encode.go

@@ -1,9 +1,7 @@
 package main
 
 import (
-	"encoding/hex"
 	"fmt"
-	"strings"
 
 	"github.com/nbd-wtf/go-nostr/nip19"
 	"github.com/urfave/cli/v2"
@@ -28,36 +26,44 @@ var encode = &cli.Command{
 	Subcommands: []*cli.Command{
 		{
 			Name:  "npub",
-			Usage: "encode a hex private key into bech32 'npub' format",
+			Usage: "encode a hex public key into bech32 'npub' format",
 			Action: func(c *cli.Context) error {
-				target := getStdinOrFirstArgument(c)
+				for target := range getStdinLinesOrFirstArgument(c) {
-				if err := validate32BytesHex(target); err != nil {
+					if err := validate32BytesHex(target); err != nil {
-					return err
+						lineProcessingError(c, "invalid public key: %s", target, err)
+						continue
+					}
+
+					if npub, err := nip19.EncodePublicKey(target); err == nil {
+						fmt.Println(npub)
+					} else {
+						return err
+					}
 				}
 
-				if npub, err := nip19.EncodePublicKey(target); err == nil {
+				exitIfLineProcessingError(c)
-					fmt.Println(npub)
+				return nil
-					return nil
-				} else {
-					return err
-				}
 			},
 		},
 		{
 			Name:  "nsec",
 			Usage: "encode a hex private key into bech32 'nsec' format",
 			Action: func(c *cli.Context) error {
-				target := getStdinOrFirstArgument(c)
+				for target := range getStdinLinesOrFirstArgument(c) {
-				if err := validate32BytesHex(target); err != nil {
+					if err := validate32BytesHex(target); err != nil {
-					return err
+						lineProcessingError(c, "invalid private key: %s", target, err)
+						continue
+					}
+
+					if npub, err := nip19.EncodePrivateKey(target); err == nil {
+						fmt.Println(npub)
+					} else {
+						return err
+					}
 				}
 
-				if npub, err := nip19.EncodePrivateKey(target); err == nil {
+				exitIfLineProcessingError(c)
-					fmt.Println(npub)
+				return nil
-					return nil
-				} else {
-					return err
-				}
 			},
 		},
 		{
@@ -71,22 +77,26 @@ var encode = &cli.Command{
 				},
 			},
 			Action: func(c *cli.Context) error {
-				target := getStdinOrFirstArgument(c)
+				for target := range getStdinLinesOrFirstArgument(c) {
-				if err := validate32BytesHex(target); err != nil {
+					if err := validate32BytesHex(target); err != nil {
-					return err
+						lineProcessingError(c, "invalid public key: %s", target, err)
+						continue
+					}
+
+					relays := c.StringSlice("relay")
+					if err := validateRelayURLs(relays); err != nil {
+						return err
+					}
+
+					if npub, err := nip19.EncodeProfile(target, relays); err == nil {
+						fmt.Println(npub)
+					} else {
+						return err
+					}
 				}
 
-				relays := c.StringSlice("relay")
+				exitIfLineProcessingError(c)
-				if err := validateRelayURLs(relays); err != nil {
+				return nil
-					return err
-				}
-
-				if npub, err := nip19.EncodeProfile(target, relays); err == nil {
-					fmt.Println(npub)
-					return nil
-				} else {
-					return err
-				}
 			},
 		},
 		{
@@ -104,29 +114,33 @@ var encode = &cli.Command{
 				},
 			},
 			Action: func(c *cli.Context) error {
-				target := getStdinOrFirstArgument(c)
+				for target := range getStdinLinesOrFirstArgument(c) {
-				if err := validate32BytesHex(target); err != nil {
+					if err := validate32BytesHex(target); err != nil {
-					return err
+						lineProcessingError(c, "invalid event id: %s", target, err)
-				}
+						continue
+					}
 
-				author := c.String("author")
+					author := c.String("author")
-				if author != "" {
+					if author != "" {
-					if err := validate32BytesHex(author); err != nil {
+						if err := validate32BytesHex(author); err != nil {
+							return err
+						}
+					}
+
+					relays := c.StringSlice("relay")
+					if err := validateRelayURLs(relays); err != nil {
+						return err
+					}
+
+					if npub, err := nip19.EncodeEvent(target, relays, author); err == nil {
+						fmt.Println(npub)
+					} else {
 						return err
 					}
 				}
 
-				relays := c.StringSlice("relay")
+				exitIfLineProcessingError(c)
-				if err := validateRelayURLs(relays); err != nil {
+				return nil
-					return err
-				}
-
-				if npub, err := nip19.EncodeEvent(target, relays, author); err == nil {
-					fmt.Println(npub)
-					return nil
-				} else {
-					return err
-				}
 			},
 		},
 		{
@@ -136,7 +150,7 @@ var encode = &cli.Command{
 				&cli.StringFlag{
 					Name:     "identifier",
 					Aliases:  []string{"d"},
-					Usage:    "the \"d\" tag identifier of this replaceable event",
+					Usage:    "the \"d\" tag identifier of this replaceable event -- can also be read from stdin",
 					Required: true,
 				},
 				&cli.StringFlag{
@@ -158,64 +172,61 @@ var encode = &cli.Command{
 				},
 			},
 			Action: func(c *cli.Context) error {
-				pubkey := c.String("pubkey")
+				for d := range getStdinLinesOrBlank() {
-				if err := validate32BytesHex(pubkey); err != nil {
+					pubkey := c.String("pubkey")
-					return err
+					if err := validate32BytesHex(pubkey); err != nil {
+						return err
+					}
+
+					kind := c.Int("kind")
+					if kind < 30000 || kind >= 40000 {
+						return fmt.Errorf("kind must be between 30000 and 39999, as per NIP-16, got %d", kind)
+					}
+
+					if d == "" {
+						d = c.String("identifier")
+						if d == "" {
+							lineProcessingError(c, "\"d\" tag identifier can't be empty")
+							continue
+						}
+					}
+
+					relays := c.StringSlice("relay")
+					if err := validateRelayURLs(relays); err != nil {
+						return err
+					}
+
+					if npub, err := nip19.EncodeEntity(pubkey, kind, d, relays); err == nil {
+						fmt.Println(npub)
+					} else {
+						return err
+					}
 				}
 
-				kind := c.Int("kind")
+				exitIfLineProcessingError(c)
-				if kind < 30000 || kind >= 40000 {
+				return nil
-					return fmt.Errorf("kind must be between 30000 and 39999, as per NIP-16, got %d", kind)
-				}
-
-				d := c.String("identifier")
-				if d == "" {
-					return fmt.Errorf("\"d\" tag identifier can't be empty")
-				}
-
-				relays := c.StringSlice("relay")
-				if err := validateRelayURLs(relays); err != nil {
-					return err
-				}
-
-				if npub, err := nip19.EncodeEntity(pubkey, kind, d, relays); err == nil {
-					fmt.Println(npub)
-					return nil
-				} else {
-					return err
-				}
 			},
 		},
 		{
 			Name:  "note",
 			Usage: "generate note1 event codes (not recommended)",
 			Action: func(c *cli.Context) error {
-				target := getStdinOrFirstArgument(c)
+				for target := range getStdinLinesOrFirstArgument(c) {
-				if err := validate32BytesHex(target); err != nil {
+					if err := validate32BytesHex(target); err != nil {
-					return err
+						lineProcessingError(c, "invalid event id: %s", target, err)
+						continue
+					}
+
+					if note, err := nip19.EncodeNote(target); err == nil {
+						fmt.Println(note)
+					} else {
+						return err
+					}
 				}
 
-				if npub, err := nip19.EncodeNote(target); err == nil {
+				exitIfLineProcessingError(c)
-					fmt.Println(npub)
+				return nil
-					return nil
-				} else {
-					return err
-				}
 			},
 		},
 	},
 }
-
-func validate32BytesHex(target string) error {
-	if _, err := hex.DecodeString(target); err != nil {
-		return fmt.Errorf("target '%s' is not valid hex: %s", target, err)
-	}
-	if len(target) != 64 {
-		return fmt.Errorf("expected '%s' to be 64 characters (32 bytes), got %d", target, len(target))
-	}
-	if strings.ToLower(target) != target {
-		return fmt.Errorf("expected target to be all lowercase hex. try again with '%s'", strings.ToLower(target))
-	}
-
-	return nil
-}

event.go

@@ -9,8 +9,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/bgentry/speakeasy"
 	"github.com/mailru/easyjson"
 	"github.com/nbd-wtf/go-nostr"
+	"github.com/nbd-wtf/go-nostr/nip19"
 	"github.com/nbd-wtf/go-nostr/nson"
 	"github.com/urfave/cli/v2"
 )
@@ -35,10 +37,14 @@ example:
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:        "sec",
-			Usage:       "secret key to sign the event",
+			Usage:       "secret key to sign the event, as hex or nsec",
 			DefaultText: "the key '1'",
 			Value:       "0000000000000000000000000000000000000000000000000000000000000001",
 		},
+		&cli.BoolFlag{
+			Name:  "prompt-sec",
+			Usage: "prompt the user to paste a hex or nsec with which to sign the event",
+		},
 		&cli.BoolFlag{
 			Name:  "envelope",
 			Usage: "print the event enveloped in a [\"EVENT\", ...] message ready to be sent to a relay",
@@ -90,6 +96,34 @@ example:
 	},
 	ArgsUsage: "[relay...]",
 	Action: func(c *cli.Context) error {
+		// gather the secret key first
+		sec := c.String("sec")
+		if c.Bool("prompt-sec") {
+			if isPiped() {
+				return fmt.Errorf("can't prompt for a secret key when processing data from a pipe, try again without --prompt-sec")
+			}
+			var err error
+			sec, err = speakeasy.FAsk(os.Stderr, "type your secret key as nsec or hex: ")
+			if err != nil {
+				return fmt.Errorf("failed to get secret key: %w", err)
+			}
+		}
+		if strings.HasPrefix(sec, "nsec1") {
+			_, hex, err := nip19.Decode(sec)
+			if err != nil {
+				return fmt.Errorf("invalid nsec: %w", err)
+			}
+			sec = hex.(string)
+		}
+		if len(sec) > 64 {
+			return fmt.Errorf("invalid secret key: too large")
+		}
+		sec = strings.Repeat("0", 64-len(sec)) + sec // left-pad
+		if err := validate32BytesHex(sec); err != nil {
+			return fmt.Errorf("invalid secret key")
+		}
+
+		// then process input and generate events
 		for stdinEvent := range getStdinLinesOrBlank() {
 			evt := nostr.Event{
 				Tags: make(nostr.Tags, 0, 3),
@@ -164,7 +198,7 @@ example:
 			}
 
 			if evt.Sig == "" || mustRehashAndResign {
-				if err := evt.Sign(c.String("sec")); err != nil {
+				if err := evt.Sign(sec); err != nil {
 					return fmt.Errorf("error signing with provided key: %w", err)
 				}
 			}

fetch.go

@@ -24,67 +24,71 @@ var fetch = &cli.Command{
 	},
 	ArgsUsage: "[nip19code]",
 	Action: func(c *cli.Context) error {
-		filter := nostr.Filter{}
+		for code := range getStdinLinesOrFirstArgument(c) {
-		code := getStdinOrFirstArgument(c)
+			filter := nostr.Filter{}
 
-		prefix, value, err := nip19.Decode(code)
+			prefix, value, err := nip19.Decode(code)
-		if err != nil {
+			if err != nil {
-			return err
+				lineProcessingError(c, "failed to decode: %s", err)
-		}
+				continue
-
-		relays := c.StringSlice("relay")
-		if err := validateRelayURLs(relays); err != nil {
-			return err
-		}
-		var authorHint string
-
-		switch prefix {
-		case "nevent":
-			v := value.(nostr.EventPointer)
-			filter.IDs = append(filter.IDs, v.ID)
-			if v.Author != "" {
-				authorHint = v.Author
 			}
-			relays = v.Relays
-		case "naddr":
-			v := value.(nostr.EntityPointer)
-			filter.Tags = nostr.TagMap{"d": []string{v.Identifier}}
-			filter.Kinds = append(filter.Kinds, v.Kind)
-			filter.Authors = append(filter.Authors, v.PublicKey)
-			authorHint = v.PublicKey
-			relays = v.Relays
-		case "nprofile":
-			v := value.(nostr.ProfilePointer)
-			filter.Authors = append(filter.Authors, v.PublicKey)
-			filter.Kinds = append(filter.Kinds, 0)
-			authorHint = v.PublicKey
-			relays = v.Relays
-		case "npub":
-			v := value.(string)
-			filter.Authors = append(filter.Authors, v)
-			filter.Kinds = append(filter.Kinds, 0)
-			authorHint = v
-		}
 
-		pool := nostr.NewSimplePool(c.Context)
+			relays := c.StringSlice("relay")
-		if authorHint != "" {
+			if err := validateRelayURLs(relays); err != nil {
-			relayList := sdk.FetchRelaysForPubkey(c.Context, pool, authorHint,
+				return err
-				"wss://purplepag.es", "wss://offchain.pub", "wss://public.relaying.io")
+			}
-			for _, relayListItem := range relayList {
+			var authorHint string
-				if relayListItem.Outbox {
+
-					relays = append(relays, relayListItem.URL)
+			switch prefix {
+			case "nevent":
+				v := value.(nostr.EventPointer)
+				filter.IDs = append(filter.IDs, v.ID)
+				if v.Author != "" {
+					authorHint = v.Author
+				}
+				relays = v.Relays
+			case "naddr":
+				v := value.(nostr.EntityPointer)
+				filter.Tags = nostr.TagMap{"d": []string{v.Identifier}}
+				filter.Kinds = append(filter.Kinds, v.Kind)
+				filter.Authors = append(filter.Authors, v.PublicKey)
+				authorHint = v.PublicKey
+				relays = v.Relays
+			case "nprofile":
+				v := value.(nostr.ProfilePointer)
+				filter.Authors = append(filter.Authors, v.PublicKey)
+				filter.Kinds = append(filter.Kinds, 0)
+				authorHint = v.PublicKey
+				relays = v.Relays
+			case "npub":
+				v := value.(string)
+				filter.Authors = append(filter.Authors, v)
+				filter.Kinds = append(filter.Kinds, 0)
+				authorHint = v
+			}
+
+			pool := nostr.NewSimplePool(c.Context)
+			if authorHint != "" {
+				relayList := sdk.FetchRelaysForPubkey(c.Context, pool, authorHint,
+					"wss://purplepag.es", "wss://offchain.pub", "wss://public.relaying.io")
+				for _, relayListItem := range relayList {
+					if relayListItem.Outbox {
+						relays = append(relays, relayListItem.URL)
+					}
 				}
 			}
+
+			if len(relays) == 0 {
+				lineProcessingError(c, "no relay hints found")
+				continue
+			}
+
+			for ie := range pool.SubManyEose(c.Context, relays, nostr.Filters{filter}) {
+				fmt.Println(ie.Event)
+			}
 		}
 
-		if len(relays) == 0 {
+		exitIfLineProcessingError(c)
-			return fmt.Errorf("no relay hints found")
-		}
-
-		for ie := range pool.SubManyEose(c.Context, relays, nostr.Filters{filter}) {
-			fmt.Println(ie.Event)
-		}
-
 		return nil
 	},
 }

go.mod

@@ -5,6 +5,7 @@ go 1.21
 toolchain go1.21.0
 
 require (
+	github.com/bgentry/speakeasy v0.1.0
 	github.com/mailru/easyjson v0.7.7
 	github.com/nbd-wtf/go-nostr v0.25.3
 	github.com/nbd-wtf/nostr-sdk v0.0.2

go.sum

@@ -1,4 +1,6 @@
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
+github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
 github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M=
 github.com/btcsuite/btcd v0.23.0/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY=

helpers.go

@@ -2,10 +2,9 @@ package main
 
 import (
 	"bufio"
-	"bytes"
 	"context"
+	"encoding/hex"
 	"fmt"
-	"io"
 	"net/url"
 	"os"
 	"strings"
@@ -17,41 +16,53 @@ const (
 	LINE_PROCESSING_ERROR = iota
 )
 
-func getStdinLinesOrBlank() chan string {
+func isPiped() bool {
-	ch := make(chan string)
+	stat, _ := os.Stdin.Stat()
-	go func() {
+	return stat.Mode()&os.ModeCharDevice == 0
-		if stat, _ := os.Stdin.Stat(); stat.Mode()&os.ModeCharDevice == 0 {
-			// piped
-			scanner := bufio.NewScanner(os.Stdin)
-			for scanner.Scan() {
-				ch <- scanner.Text()
-			}
-		} else {
-			// not piped
-			ch <- ""
-		}
-		close(ch)
-	}()
-	return ch
 }
 
-func getStdinOrFirstArgument(c *cli.Context) string {
+func getStdinLinesOrBlank() chan string {
+	multi := make(chan string)
+	if hasStdinLines := writeStdinLinesOrNothing(multi); !hasStdinLines {
+		single := make(chan string, 1)
+		single <- ""
+		close(single)
+		return single
+	} else {
+		return multi
+	}
+}
+
+func getStdinLinesOrFirstArgument(c *cli.Context) chan string {
 	// try the first argument
 	target := c.Args().First()
 	if target != "" {
-		return target
+		single := make(chan string, 1)
+		single <- target
+		return single
 	}
 
 	// try the stdin
-	stat, _ := os.Stdin.Stat()
+	multi := make(chan string)
-	if (stat.Mode() & os.ModeCharDevice) == 0 {
+	writeStdinLinesOrNothing(multi)
-		read := bytes.NewBuffer(make([]byte, 0, 1000))
+	return multi
-		_, err := io.Copy(read, os.Stdin)
+}
-		if err == nil {
+
-			return strings.TrimSpace(read.String())
+func writeStdinLinesOrNothing(ch chan string) (hasStdinLines bool) {
-		}
+	if isPiped() {
+		// piped
+		go func() {
+			scanner := bufio.NewScanner(os.Stdin)
+			for scanner.Scan() {
+				ch <- strings.TrimSpace(scanner.Text())
+			}
+			close(ch)
+		}()
+		return true
+	} else {
+		// not piped
+		return false
 	}
-	return ""
 }
 
 func validateRelayURLs(wsurls []string) error {
@@ -73,6 +84,20 @@ func validateRelayURLs(wsurls []string) error {
 	return nil
 }
 
+func validate32BytesHex(target string) error {
+	if _, err := hex.DecodeString(target); err != nil {
+		return fmt.Errorf("target '%s' is not valid hex: %s", target, err)
+	}
+	if len(target) != 64 {
+		return fmt.Errorf("expected '%s' to be 64 characters (32 bytes), got %d", target, len(target))
+	}
+	if strings.ToLower(target) != target {
+		return fmt.Errorf("expected target to be all lowercase hex. try again with '%s'", strings.ToLower(target))
+	}
+
+	return nil
+}
+
 func lineProcessingError(c *cli.Context, msg string, args ...any) {
 	c.Context = context.WithValue(c.Context, LINE_PROCESSING_ERROR, true)
 	fmt.Fprintf(os.Stderr, msg+"\n", args...)

req.go

@@ -99,7 +99,7 @@ example:
 			filter := nostr.Filter{}
 			if stdinFilter != "" {
 				if err := json.Unmarshal([]byte(stdinFilter), &filter); err != nil {
-					lineProcessingError(c, "invalid filter received from stdin: %s", err)
+					lineProcessingError(c, "invalid filter '%s' received from stdin: %s", stdinFilter, err)
 					continue
 				}
 			}