cleanup

Author: fullpipe

.gitignore

@@ -16,6 +16,7 @@
 coverage.*
 *.coverprofile
 profile.cov
+*.prof
 
 # Dependency directories (remove the comment below to include it)
 # vendor/

dictionary.go

@@ -10,14 +10,29 @@ import (
 )
 
 type dictionary struct {
-	bitsToWord    map[string]string
-	wordToBits    map[string]string
-	bitsToInt     map[string]int
-	bitsBatchSize int
+	// bitsToWord ["00101"] => "banana"
+	bitsToWord map[string]string
+
+	// wordToBits ["banana"] => "00101"
+	wordToBits map[string]string
+
+	// bitsToInt ["00101"] => 5
+	bitsToInt map[string]int
+
+	// bitsStringLen how many bits could be encoded with provided words.
+	//
+	// example: 32 words could encode 5 bits [0 0 0 0 0]
+	bitsStringLen int
+
+	// wordsChecksum is used to calc mnemonic checksum,
+	// so mnemonic is binded to specific dictionary
 	wordsChecksum []byte
-	checksumLen   int
+
+	// checksumLen how many bits used for checksum
+	checksumLen int
+
 	// how many bit in checksum are for tail len
-	// bitsBatchSize = checksumLen + tailChecksumLen
+	// bitsStringLen = checksumLen + tailChecksumLen
 	tailChecksumLen int
 }
 
@@ -36,8 +51,7 @@ func NewDictionary(words []string) (Recoder, error) {
 		return nil, errors.New("dictionary should be complete and len(words) == 2^N")
 	}
 
-	bitsBatchSize := int(math.Log2(float64(len(words))))
-
+	bitsStringLen := int(math.Log2(float64(len(words))))
 	bitsToWord := make(map[string]string, len(words))
 	wordToBits := make(map[string]string, len(words))
 	bitsToInt := make(map[string]int, len(words))
@@ -55,32 +69,33 @@ func NewDictionary(words []string) (Recoder, error) {
 		}
 		dups[word] = true
 
-		bitWord := idxToBitString(i, bitsBatchSize)
+		bitWord := idxToBitString(i, bitsStringLen)
 		bitsToWord[bitWord] = word
 		wordToBits[word] = bitWord
 		bitsToInt[bitWord] = i
 
 		h.Write([]byte(word))
 	}
 
-	tailChecksumLen := tailBitsLenInChecksum(bitsBatchSize)
-	checksumLen := bitsBatchSize - tailChecksumLen
+	tailChecksumLen := tailBitsLenInChecksum(bitsStringLen)
+	checksumLen := bitsStringLen - tailChecksumLen
 
 	return &dictionary{
 		bitsToWord:      bitsToWord,
 		wordToBits:      wordToBits,
 		bitsToInt:       bitsToInt,
-		bitsBatchSize:   bitsBatchSize,
+		bitsStringLen:   bitsStringLen,
 		wordsChecksum:   h.Sum(nil),
 		checksumLen:     checksumLen,
 		tailChecksumLen: tailChecksumLen,
 	}, nil
 }
 
-func tailBitsLenInChecksum(bitsBatchSize int) int {
+// tailBitsLenInChecksum calcs how many bits is required to encode
+func tailBitsLenInChecksum(bitsStringLen int) int {
 	tailChecksumLen := 0
-	if bitsBatchSize > 1 {
-		tailChecksumLen = int(math.Ceil(math.Log2(float64(bitsBatchSize))))
+	if bitsStringLen > 1 {
+		tailChecksumLen = int(math.Ceil(math.Log2(float64(bitsStringLen))))
 	}
 
 	return tailChecksumLen
@@ -102,7 +117,7 @@ func idxToBitString(idx int, bitLen int) string {
 	n := big.NewInt(int64(idx))
 	b := padByteSlice(n.Bytes(), 2)
 
-	str := fmt.Sprintf("%08b", b[0]) + fmt.Sprintf("%08b", b[1])
+	str := fmt.Sprintf("%08b%08b", b[0], b[1])
 
 	return str[16-bitLen:]
 }
@@ -123,16 +138,17 @@ func (d *dictionary) Encode(data []byte) ([]string, error) {
 	bits := bitsBuilder.String()
 
 	// how many bits we should take from last word
-	tailLen := len(bits) % d.bitsBatchSize
-	tailLenBits := idxToBitString(tailLen, d.bitsBatchSize)
+	tailLen := len(bits) % d.bitsStringLen
+	tailLenBits := idxToBitString(tailLen, d.bitsStringLen)
 	tailLenBits = tailLenBits[len(tailLenBits)-d.tailChecksumLen:]
 
 	// add checksum at the begining
 	// so when decoding we dont care about its paddings
+	// NOTE: len(cs + tailLenBits) == bitsStringLen, and encoded with one word
 	bits = cs + tailLenBits + bits
 
-	for i := 0; i < len(bits)-tailLen; i += d.bitsBatchSize {
-		lb := bits[i : i+d.bitsBatchSize]
+	for i := 0; i < len(bits)-tailLen; i += d.bitsStringLen {
+		lb := bits[i : i+d.bitsStringLen]
 		word, ok := d.bitsToWord[lb]
 		if !ok {
 			return mnemonic, fmt.Errorf("bits-to-word mapping not found for bits: %s", lb)
@@ -143,7 +159,7 @@ func (d *dictionary) Encode(data []byte) ([]string, error) {
 
 	if tailLen > 0 {
 		tailBits := bits[len(bits)-tailLen:]
-		tailBits += strings.Repeat("1", d.bitsBatchSize-tailLen)
+		tailBits += strings.Repeat("1", d.bitsStringLen-tailLen)
 		tailWord, ok := d.bitsToWord[tailBits]
 		if !ok {
 			return mnemonic, fmt.Errorf("bits-to-word mapping not found for tail bits: %s", tailBits)
@@ -168,7 +184,7 @@ func (d *dictionary) Decode(mnemonic []string) ([]byte, error) {
 
 	tailLen := 0
 	if d.tailChecksumLen > 0 {
-		tailLenBits = strings.Repeat("0", d.bitsBatchSize-d.tailChecksumLen) + tailLenBits
+		tailLenBits = strings.Repeat("0", d.bitsStringLen-d.tailChecksumLen) + tailLenBits
 		tailLen, ok = d.bitsToInt[tailLenBits]
 		if !ok {
 			return nil, errors.New("invalid tail")
@@ -186,7 +202,7 @@ func (d *dictionary) Decode(mnemonic []string) ([]byte, error) {
 
 	bitString := bitsBuilder.String()
 	if tailLen > 0 {
-		paddingLen := d.bitsBatchSize - tailLen
+		paddingLen := d.bitsStringLen - tailLen
 		bitString = bitString[:len(bitString)-paddingLen]
 	}
 
@@ -196,7 +212,7 @@ func (d *dictionary) Decode(mnemonic []string) ([]byte, error) {
 
 	bitCounter := 0
 	for b := 0; b < len(bitString)/8; b++ {
-		for bit := 0; bit < 8; bit++ {
+		for bit := range 8 {
 			dst[b] |= (src[bitCounter] & bitMask) << (7 - bit)
 			bitCounter++
 		}
@@ -227,7 +243,7 @@ func (d *dictionary) checksum(data []byte) (string, error) {
 	}
 
 	sum := h.Sum(nil)
-	str := fmt.Sprintf("%08b", sum[0]) + fmt.Sprintf("%08b", sum[1])
+	str := fmt.Sprintf("%08b%08b", sum[0], sum[1])
 
 	return str[:d.checksumLen], nil
 }

dictionary_test.go

@@ -245,11 +245,11 @@ func TestDic_Decode(t *testing.T) {
 }
 
 func TestDic_Random(t *testing.T) {
-	for i := 0; i < 10000; i++ {
+	for range 1000 {
 		wordsExp := r.IntN(10) + 1
 		wordsNum := int(math.Pow(2, float64(wordsExp)))
 		words := make([]string, 0, wordsNum)
-		for j := 0; j < wordsNum; j++ {
+		for range wordsNum {
 			words = append(words, randomWord())
 		}