feat(BUX-296): bump as slice

.github/workflows/test-and-lint.yml

@@ -16,9 +16,20 @@ jobs:
       run: |
         curl -sL https://taskfile.dev/install.sh | sh
         sudo mv ./bin/task /usr/local/bin
-    - name: Run Tests
-      run: task test
+    - name: Cache code
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/go/pkg/mod              # Module download cache
+          ~/.cache/go-build         # Build cache (Linux)
+          ~/Library/Caches/go-build # Build cache (Mac)
+          '%LocalAppData%\go-build' # Build cache (Windows)
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-
     - name: Setup golangci-lint
       uses: golangci/golangci-lint-action@v2
+    - name: Run Tests
+      run: task test
     - name: Run Lint
       run: task lint

bump.go

@@ -0,0 +1,112 @@
+package paymail
+
+import (
+	"errors"
+	"github.com/libsv/go-bc"
+	"github.com/libsv/go-bt/v2"
+)
+
+// BUMPs represents a slice of BUMPs - BSV Unified Merkle Paths
+type BUMPs []BUMP
+
+// BUMP is a struct that represents a whole BUMP format
+type BUMP struct {
+	blockHeight uint64
+	path        [][]BUMPLeaf
+}
+
+// BUMPLeaf represents each BUMP path element
+type BUMPLeaf struct {
+	hash      string
+	txId      bool
+	duplicate bool
+	offset    uint64
+}
+
+// Flags which are used to determine the type of BUMPLeaf
+const (
+	dataFlag bt.VarInt = iota
+	duplicateFlag
+	txIDFlag
+)
+
+func (b BUMP) calculateMerkleRoots() ([]string, error) {
+	merkleRoots := make([]string, 0)
+
+	for _, bumpPathElement := range b.path[0] {
+		merkleRoot, err := calculateMerkleRoot(bumpPathElement, b)
+		if err != nil {
+			return nil, err
+		}
+		merkleRoots = append(merkleRoots, merkleRoot)
+	}
+	return merkleRoots, nil
+}
+
+func findLeafByOffset(offset uint64, bumpLeaves []BUMPLeaf) *BUMPLeaf {
+	for _, bumpTx := range bumpLeaves {
+		if bumpTx.offset == offset {
+			return &bumpTx
+		}
+	}
+	return nil
+}
+
+// calculateMerkleRoots will calculate one merkle root for tx in the BUMPPath
+func calculateMerkleRoot(baseLeaf BUMPLeaf, bump BUMP) (string, error) {
+	calculatedHash := baseLeaf.hash
+	offset := baseLeaf.offset
+
+	for _, bLevel := range bump.path {
+		newOffset := getOffsetPair(offset)
+		leafInPair := findLeafByOffset(newOffset, bLevel)
+		if leafInPair == nil {
+			return "", errors.New("could not find pair")
+		}
+
+		leftNode, rightNode := prepareNodes(baseLeaf, offset, *leafInPair, newOffset)
+
+		str, err := bc.MerkleTreeParentStr(leftNode, rightNode)
+		if err != nil {
+			return "", err
+		}
+		calculatedHash = str
+
+		offset = offset / 2
+
+		baseLeaf = BUMPLeaf{
+			hash:   calculatedHash,
+			offset: offset,
+		}
+	}
+
+	return calculatedHash, nil
+}
+
+func getOffsetPair(offset uint64) uint64 {
+	if offset%2 == 0 {
+		return offset + 1
+	}
+	return offset - 1
+}
+
+func prepareNodes(baseLeaf BUMPLeaf, offset uint64, leafInPair BUMPLeaf, newOffset uint64) (string, string) {
+	var baseLeafHash, pairLeafHash string
+
+	if baseLeaf.duplicate {
+		baseLeafHash = leafInPair.hash
+	} else {
+		baseLeafHash = baseLeaf.hash
+	}
+
+	if leafInPair.duplicate {
+		pairLeafHash = baseLeaf.hash
+	} else {
+		pairLeafHash = leafInPair.hash
+	}
+
+	if newOffset > offset {
+		return baseLeafHash, pairLeafHash
+	}
+	return pairLeafHash, baseLeafHash
+}