replace vendored bech32 code with btcd library.

nip19/bech32.go

@@ -1,236 +0,0 @@
-package nip19
-
-import (
-	"fmt"
-	"strings"
-)
-
-const charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
-
-var gen = []int{0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3}
-
-// decode decodes a bech32 encoded string, returning the human-readable
-// part and the data part excluding the checksum.
-func decode(bech string) (string, []byte, error) {
-	// Only ASCII characters between 33 and 126 are allowed.
-	for i := 0; i < len(bech); i++ {
-		if bech[i] < 33 || bech[i] > 126 {
-			return "", nil, fmt.Errorf("invalid character in string: '%c'", bech[i])
-		}
-	}
-
-	// The characters must be either all lowercase or all uppercase.
-	lower := strings.ToLower(bech)
-	upper := strings.ToUpper(bech)
-	if bech != lower && bech != upper {
-		return "", nil, fmt.Errorf("string not all lowercase or all uppercase")
-	}
-
-	// We'll work with the lowercase string from now on.
-	bech = lower
-
-	// The string is invalid if the last '1' is non-existent, it is the
-	// first character of the string (no human-readable part) or one of the
-	// last 6 characters of the string (since checksum cannot contain '1'),
-	// or if the string is more than 90 characters in total.
-	one := strings.LastIndexByte(bech, '1')
-	if one < 1 || one+7 > len(bech) {
-		return "", nil, fmt.Errorf("invalid index of 1")
-	}
-
-	// The human-readable part is everything before the last '1'.
-	hrp := bech[:one]
-	data := bech[one+1:]
-
-	// Each character corresponds to the byte with value of the index in
-	// 'charset'.
-	decoded, err := toBytes(data)
-	if err != nil {
-		return "", nil, fmt.Errorf("failed converting data to bytes: %s", err.Error())
-	}
-
-	if !bech32VerifyChecksum(hrp, decoded) {
-		moreInfo := ""
-		checksum := bech[len(bech)-6:]
-		expected, err := toChars(bech32Checksum(hrp,
-			decoded[:len(decoded)-6]))
-		if err == nil {
-			moreInfo = fmt.Sprintf("Expected %v, got %v.", expected, checksum)
-		}
-		return "", nil, fmt.Errorf("checksum failed. " + moreInfo)
-	}
-
-	// We exclude the last 6 bytes, which is the checksum.
-	return hrp, decoded[:len(decoded)-6], nil
-}
-
-// Encode encodes a byte slice into a bech32 string with the
-// human-readable part hrb. Note that the bytes must each encode 5 bits
-// (base32).
-func encode(hrp string, data []byte) (string, error) {
-	// Calculate the checksum of the data and append it at the end.
-	checksum := bech32Checksum(hrp, data)
-	combined := append(data, checksum...)
-
-	// The resulting bech32 string is the concatenation of the hrp, the
-	// separator 1, data and checksum. Everything after the separator is
-	// represented using the specified charset.
-	dataChars, err := toChars(combined)
-	if err != nil {
-		return "", fmt.Errorf("unable to convert data bytes to chars: %s", err.Error())
-	}
-	return hrp + "1" + dataChars, nil
-}
-
-// toBytes converts each character in the string 'chars' to the value of the
-// index of the correspoding character in 'charset'.
-func toBytes(chars string) ([]byte, error) {
-	decoded := make([]byte, 0, len(chars))
-	for i := 0; i < len(chars); i++ {
-		index := strings.IndexByte(charset, chars[i])
-		if index < 0 {
-			return nil, fmt.Errorf("invalid character not part of "+
-				"charset: %v", chars[i])
-		}
-		decoded = append(decoded, byte(index))
-	}
-	return decoded, nil
-}
-
-// toChars converts the byte slice 'data' to a string where each byte in 'data'
-// encodes the index of a character in 'charset'.
-func toChars(data []byte) (string, error) {
-	result := make([]byte, 0, len(data))
-	for _, b := range data {
-		if int(b) >= len(charset) {
-			return "", fmt.Errorf("invalid data byte: %v", b)
-		}
-		result = append(result, charset[b])
-	}
-	return string(result), nil
-}
-
-// convertBits converts a byte slice where each byte is encoding fromBits bits,
-// to a byte slice where each byte is encoding toBits bits.
-func convertBits(data []byte, fromBits, toBits uint8, pad bool) ([]byte, error) {
-	if fromBits < 1 || fromBits > 8 || toBits < 1 || toBits > 8 {
-		return nil, fmt.Errorf("only bit groups between 1 and 8 allowed")
-	}
-
-	// The final bytes, each byte encoding toBits bits.
-	var regrouped []byte
-
-	// Keep track of the next byte we create and how many bits we have
-	// added to it out of the toBits goal.
-	nextByte := byte(0)
-	filledBits := uint8(0)
-
-	for _, b := range data {
-
-		// Discard unused bits.
-		b = b << (8 - fromBits)
-
-		// How many bits remaining to extract from the input data.
-		remFromBits := fromBits
-		for remFromBits > 0 {
-			// How many bits remaining to be added to the next byte.
-			remToBits := toBits - filledBits
-
-			// The number of bytes to next extract is the minimum of
-			// remFromBits and remToBits.
-			toExtract := remFromBits
-			if remToBits < toExtract {
-				toExtract = remToBits
-			}
-
-			// Add the next bits to nextByte, shifting the already
-			// added bits to the left.
-			nextByte = (nextByte << toExtract) | (b >> (8 - toExtract))
-
-			// Discard the bits we just extracted and get ready for
-			// next iteration.
-			b = b << toExtract
-			remFromBits -= toExtract
-			filledBits += toExtract
-
-			// If the nextByte is completely filled, we add it to
-			// our regrouped bytes and start on the next byte.
-			if filledBits == toBits {
-				regrouped = append(regrouped, nextByte)
-				filledBits = 0
-				nextByte = 0
-			}
-		}
-	}
-
-	// We pad any unfinished group if specified.
-	if pad && filledBits > 0 {
-		nextByte = nextByte << (toBits - filledBits)
-		regrouped = append(regrouped, nextByte)
-		filledBits = 0
-		nextByte = 0
-	}
-
-	// Any incomplete group must be <= 4 bits, and all zeroes.
-	if filledBits > 0 && (filledBits > 4 || nextByte != 0) {
-		return nil, fmt.Errorf("invalid incomplete group")
-	}
-
-	return regrouped, nil
-}
-
-// For more details on the checksum calculation, please refer to BIP 173.
-func bech32Checksum(hrp string, data []byte) []byte {
-	// Convert the bytes to list of integers, as this is needed for the
-	// checksum calculation.
-	integers := make([]int, len(data))
-	for i, b := range data {
-		integers[i] = int(b)
-	}
-	values := append(bech32HrpExpand(hrp), integers...)
-	values = append(values, []int{0, 0, 0, 0, 0, 0}...)
-	polymod := bech32Polymod(values) ^ 1
-	var res []byte
-	for i := 0; i < 6; i++ {
-		res = append(res, byte((polymod>>uint(5*(5-i)))&31))
-	}
-	return res
-}
-
-// For more details on the polymod calculation, please refer to BIP 173.
-func bech32Polymod(values []int) int {
-	chk := 1
-	for _, v := range values {
-		b := chk >> 25
-		chk = (chk&0x1ffffff)<<5 ^ v
-		for i := 0; i < 5; i++ {
-			if (b>>uint(i))&1 == 1 {
-				chk ^= gen[i]
-			}
-		}
-	}
-	return chk
-}
-
-// For more details on HRP expansion, please refer to BIP 173.
-func bech32HrpExpand(hrp string) []int {
-	v := make([]int, 0, len(hrp)*2+1)
-	for i := 0; i < len(hrp); i++ {
-		v = append(v, int(hrp[i]>>5))
-	}
-	v = append(v, 0)
-	for i := 0; i < len(hrp); i++ {
-		v = append(v, int(hrp[i]&31))
-	}
-	return v
-}
-
-// For more details on the checksum verification, please refer to BIP 173.
-func bech32VerifyChecksum(hrp string, data []byte) bool {
-	integers := make([]int, len(data))
-	for i, b := range data {
-		integers[i] = int(b)
-	}
-	concat := append(bech32HrpExpand(hrp), integers...)
-	return bech32Polymod(concat) == 1
-}

nip19/nip19.go

@@ -6,16 +6,17 @@ import (
 	"encoding/hex"
 	"fmt"
 
+	"github.com/btcsuite/btcd/btcutil/bech32"
 	"github.com/nbd-wtf/go-nostr"
 )
 
 func Decode(bech32string string) (prefix string, value any, err error) {
-	prefix, bits5, err := decode(bech32string)
+	prefix, bits5, err := bech32.DecodeNoLimit(bech32string)
 	if err != nil {
 		return "", nil, err
 	}
 
-	data, err := convertBits(bits5, 5, 8, false)
+	data, err := bech32.ConvertBits(bits5, 5, 8, false)
 	if err != nil {
 		return prefix, nil, fmt.Errorf("failed translating data into 8 bits: %s", err.Error())
 	}
@@ -119,12 +120,12 @@ func EncodePrivateKey(privateKeyHex string) (string, error) {
 		return "", fmt.Errorf("failed to decode private key hex: %w", err)
 	}
 
-	bits5, err := convertBits(b, 8, 5, true)
+	bits5, err := bech32.ConvertBits(b, 8, 5, true)
 	if err != nil {
 		return "", err
 	}
 
-	return encode("nsec", bits5)
+	return bech32.Encode("nsec", bits5)
 }
 
 func EncodePublicKey(publicKeyHex string) (string, error) {
@@ -133,12 +134,12 @@ func EncodePublicKey(publicKeyHex string) (string, error) {
 		return "", fmt.Errorf("failed to decode public key hex: %w", err)
 	}
 
-	bits5, err := convertBits(b, 8, 5, true)
+	bits5, err := bech32.ConvertBits(b, 8, 5, true)
 	if err != nil {
 		return "", err
 	}
 
-	return encode("npub", bits5)
+	return bech32.Encode("npub", bits5)
 }
 
 func EncodeNote(eventIdHex string) (string, error) {
@@ -147,12 +148,12 @@ func EncodeNote(eventIdHex string) (string, error) {
 		return "", fmt.Errorf("failed to decode event id hex: %w", err)
 	}
 
-	bits5, err := convertBits(b, 8, 5, true)
+	bits5, err := bech32.ConvertBits(b, 8, 5, true)
 	if err != nil {
 		return "", err
 	}
 
-	return encode("note", bits5)
+	return bech32.Encode("note", bits5)
 }
 
 func EncodeProfile(publicKeyHex string, relays []string) (string, error) {
@@ -167,12 +168,12 @@ func EncodeProfile(publicKeyHex string, relays []string) (string, error) {
 		writeTLVEntry(buf, TLVRelay, []byte(url))
 	}
 
-	bits5, err := convertBits(buf.Bytes(), 8, 5, true)
+	bits5, err := bech32.ConvertBits(buf.Bytes(), 8, 5, true)
 	if err != nil {
 		return "", fmt.Errorf("failed to convert bits: %w", err)
 	}
 
-	return encode("nprofile", bits5)
+	return bech32.Encode("nprofile", bits5)
 }
 
 func EncodeEvent(eventIdHex string, relays []string, author string) (string, error) {
@@ -191,12 +192,12 @@ func EncodeEvent(eventIdHex string, relays []string, author string) (string, err
 		writeTLVEntry(buf, TLVAuthor, pubkey)
 	}
 
-	bits5, err := convertBits(buf.Bytes(), 8, 5, true)
+	bits5, err := bech32.ConvertBits(buf.Bytes(), 8, 5, true)
 	if err != nil {
 		return "", fmt.Errorf("failed to convert bits: %w", err)
 	}
 
-	return encode("nevent", bits5)
+	return bech32.Encode("nevent", bits5)
 }
 
 func EncodeEntity(publicKey string, kind int, identifier string, relays []string) (string, error) {
@@ -218,10 +219,10 @@ func EncodeEntity(publicKey string, kind int, identifier string, relays []string
 	binary.BigEndian.PutUint32(kindBytes, uint32(kind))
 	writeTLVEntry(buf, TLVKind, kindBytes)
 
-	bits5, err := convertBits(buf.Bytes(), 8, 5, true)
+	bits5, err := bech32.ConvertBits(buf.Bytes(), 8, 5, true)
 	if err != nil {
 		return "", fmt.Errorf("failed to convert bits: %w", err)
 	}
 
-	return encode("naddr", bits5)
+	return bech32.Encode("naddr", bits5)
 }