feat(MerkleTree): Consolidate MerkleTree repo into core kit

Author: rickhohler

Sources/DesignAlgorithmsKit/MerkleTree/MerkleTree+Build.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+public extension MerkleTree {
+  func getAuditTrail(for itemHash: String, leaves: [MerkleTree]) -> [PathHash] {
+    guard let targetLeave = leaves.first(where: { $0.value.hash == itemHash }) else { return [] }
+    var path = [PathHash]()
+
+    var currentParent: MerkleTree? = targetLeave.parent
+    var siblingHash = itemHash
+    while let parent = currentParent {
+      if let leftHash = parent.children.left?.value.hash {
+        if let rightHash = parent.children.right?.value.hash {
+          if leftHash == siblingHash {
+            path.append(PathHash(rightHash, leaf: .right))
+          } else if rightHash == siblingHash {
+            path.append(PathHash(leftHash, leaf: .left))
+          }
+        }
+      }
+
+      siblingHash = parent.value.hash
+      currentParent = parent.parent
+    }
+    return path
+  }
+
+  private func createParent(times: Int) -> MerkleTree {
+    assert(times >= 0, "times shouldn't be negative")
+    var tree = self
+    let hash = value.hash
+    for _ in 0 ..< times {
+      let parent = MerkleTree(hash: hash)
+      parent.add(right: tree)
+      tree.parent = parent
+      tree = parent
+    }
+    return tree
+  }
+
+  static func toPowersOfTwo(_ num: Int) -> [Int] {
+    let binary = String(num, radix: 2)
+    return binary
+      .enumerated()
+      .filter { $1 == "1" }
+      .map { binary.count - $0.offset - 1 }
+  }
+
+  static func build(fromBlobs: [Data]) -> MerkleTree {
+    var leaves = ArraySlice(fromBlobs.map(MerkleTree.init(blob:)))
+    var roots = [MerkleTree]()
+    for power in toPowersOfTwo(leaves.count) {
+      if power == 0, let last = leaves.last {
+        roots.append(last)
+      } else {
+        guard !leaves.isEmpty else { continue }
+        roots.append(merge(leaves.prefix(1 << power)))
+        leaves.removeFirst(1 << power)
+      }
+    }
+
+    return merge(ArraySlice(roots))
+  }
+
+  private static func merge(_ nodes: ArraySlice<MerkleTree>) -> MerkleTree {
+    let count = nodes.count
+    assert(count != 0, "at least one node should exist")
+    if count == 1, let first = nodes.first { return first }
+    if count == 2, let first = nodes.first, let last = nodes.last {
+      return makeSiblings(first, last)
+    } else {
+      let half = (count / 2) + (count % 2)
+      return makeSiblings(merge(nodes.prefix(half)), merge(nodes.suffix(count - half)))
+    }
+  }
+
+  func audit(itemHash: String, auditTrail: [PathHash]) -> Bool {
+    var pathHashes = auditTrail
+    var siblingHash = itemHash
+
+    while !pathHashes.isEmpty {
+      let pathHash = pathHashes.removeFirst()
+      let parentHashes = pathHash.leaf == .left ? (pathHash.hash + siblingHash) : (siblingHash + pathHash.hash)
+      siblingHash = Data(parentHashes.utf8).doubleHashedHex
+    }
+
+    return siblingHash == value.hash
+  }
+
+  private static func makeSiblings(_ left: MerkleTree, _ right: MerkleTree) -> MerkleTree {
+    let heightDifference = left.height - right.height
+
+    let leftHash = left.value.hash
+    let rightHash = right.value.hash
+    let parent = MerkleTree(hash: Data((leftHash + rightHash).utf8).doubleHashedHex)
+    parent.add(left: left, right: right.createParent(times: heightDifference))
+    return parent
+  }
+}

Sources/DesignAlgorithmsKit/MerkleTree/MerkleTree.swift

@@ -0,0 +1,55 @@
+import CryptoKit
+import Foundation
+
+public typealias MerkleTree = TwoWayBinaryTree<MerkleNode>
+
+public extension MerkleTree {
+  convenience init(hash: String) {
+    self.init(MerkleNode(hash: hash))
+  }
+
+  convenience init(blob: Data) {
+    self.init(MerkleNode(blob: blob))
+  }
+
+  var height: Int {
+    var sum = 1
+    var rootChildren: TwoWayBinaryTree? = children.left
+    while let left = rootChildren {
+      sum += 1
+      rootChildren = left.children.left
+    }
+    return sum
+  }
+}
+
+extension MerkleTree: Equatable where T: Equatable {
+  public static func == (lhs: MerkleTree, rhs: MerkleTree) -> Bool {
+    lhs.value == rhs.value
+  }
+}
+
+extension MerkleTree: Hashable where T: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+  }
+}
+
+extension Digest {
+  private var bytes: [UInt8] { Array(makeIterator()) }
+  var hexStr: String {
+    bytes.map { String(format: "%02X", $0) }.joined()
+  }
+}
+
+public extension Data {
+  private var hashedHex: String { SHA256.hash(data: self).hexStr }
+  var doubleHashedHex: String { SHA256.hash(data: Data(hashedHex.utf8)).hexStr }
+}
+
+public struct MerkleNode: Hashable {
+  public let hash: String
+
+  public init(blob: Data) { hash = blob.doubleHashedHex }
+  public init(hash: String) { self.hash = hash }
+}

Sources/DesignAlgorithmsKit/MerkleTree/PathHash.swift

@@ -0,0 +1,10 @@
+public struct PathHash: Hashable {
+  public enum Leaf { case left, right }
+  public let hash: String
+  public let leaf: Leaf
+
+  public init(_ hash: String, leaf: Leaf) {
+    self.hash = hash
+    self.leaf = leaf
+  }
+}

Sources/DesignAlgorithmsKit/MerkleTree/TwoWayBinaryTree.swift

@@ -0,0 +1,17 @@
+public class TwoWayBinaryTree<T> {
+  public var value: T
+
+  weak var parent: TwoWayBinaryTree<T>?
+  public var children: (left: TwoWayBinaryTree<T>?, right: TwoWayBinaryTree<T>?)
+
+  public init(_ value: T, left: TwoWayBinaryTree<T>? = nil, right: TwoWayBinaryTree<T>? = nil) {
+    self.value = value
+    children = (left, right)
+  }
+
+  func add(left: TwoWayBinaryTree<T>? = nil, right: TwoWayBinaryTree<T>? = nil) {
+    children = (left, right)
+    left?.parent = self
+    right?.parent = self
+  }
+}