--- /dev/null
+package bech32
+
+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 Bech32Decode(bech string) (string, []byte, error) {
+ // The maximum allowed length for a bech32 string is 90. It must also
+ // be at least 8 characters, since it needs a non-empty HRP, a
+ // separator, and a 6 character checksum.
+ if len(bech) < 8 || len(bech) > 90 {
+ return "", nil, fmt.Errorf("invalid bech32 string length %d",
+ len(bech))
+ }
+ // 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: "+
+ "%v", err)
+ }
+
+ 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 Bech32Encode(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: "+
+ "%v", err)
+ }
+ 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
+}
OSDN Git Service
