use Swift Crypto for bitcoin hash testing instead of CryptoKit

Author: arik-so

.github/workflows/swift.yml

@@ -44,7 +44,7 @@ jobs:
                     tar xvvf swift-5.6-RELEASE-ubuntu20.04.tar.gz
                 env:
                     EXPECTED_SWIFT_SHASUM: 3f0d926bfc08eea00a69b1d992f2ab5e08155d97476096a3ef959fe7c4cbd58b
-            -   name: Install native Rust toolchain, Valgrind, and build utilitis
+            -   name: Install native Rust toolchain, Valgrind, and build utilities
                 run: |
                     sudo apt-get update
                     sudo apt-get -y dist-upgrade

ci/Dockerfile

@@ -1,5 +1,5 @@
 #FROM ubuntu:20.04
-FROM swift:bionic
+FROM swift:5.6-focal
 
 RUN apt-get -y update
 RUN apt-get -y dist-upgrade

ci/LDKSwift/Package.swift

@@ -12,7 +12,9 @@ let package = Package(
                     targets: ["LDKSwift"]),
             // .library(name: "LDKSwift", type: .dynamic, targets: ["LDKSwift"])
         ],
-        dependencies: [],
+        dependencies: [
+        	.package(url: "https://github.com/apple/swift-crypto.git", "1.0.0" ..< "3.0.0")
+        ],
         targets: [
             // Targets are the basic building blocks of a package. A target can define a module or a test suite.
             // Targets can depend on other targets in this package, and on products in packages this package depends on.
@@ -50,7 +52,11 @@ let package = Package(
                     ]),
             .testTarget(
                     name: "LDKSwiftTests",
-                    dependencies: ["LDKSwift", "LDKHeaders"],
+                    dependencies: [
+                    	"LDKSwift",
+                    	"LDKHeaders",
+                    	.product(name: "Crypto", package: "swift-crypto")
+					],
                     path: nil,
                     exclude: [],
                     // exclude: ["SampleTest.swift"],

ci/LDKSwift/Tests/LDKSwiftTests/HumanObjectPeerTestInstance.swift

@@ -282,9 +282,9 @@ public class HumanObjectPeerTestInstance {
                 //                self.constructor = ChannelManagerConstructor(network: LDKNetwork_Bitcoin, config: UserConfig(), current_blockchain_tip_hash: [UInt8](repeating: 0, count: 32), current_blockchain_tip_height: 0, keys_interface: self.keysInterface, fee_estimator: self.feeEstimator, chain_monitor: self.chainMonitor!, net_graph: nil, tx_broadcaster: self.txBroadcaster, logger: self.logger)
 
                 let scoringParams = ProbabilisticScoringParameters()
-                let probabalisticScorer = ProbabilisticScorer(params: scoringParams.danglingClone(), network_graph: graph)
+                let probabalisticScorer = ProbabilisticScorer(params: scoringParams, network_graph: graph)
                 let score = probabalisticScorer.as_Score()
-                let multiThreadedScorer = MultiThreadedLockableScore(score: score.dangle())
+                let multiThreadedScorer = MultiThreadedLockableScore(score: score)
 
                 self.constructor?.chain_sync_completed(persister: TestChannelManagerPersister(master: self), scorer: multiThreadedScorer)
                 self.channelManager = self.constructor!.channelManager

ci/LDKSwift/Tests/LDKSwiftTests/bitcoin/BTCBlock.swift

@@ -0,0 +1,141 @@
+//
+//  BTCBlock.swift
+//  DirectBindingsApp
+//
+//  Created by Arik Sosman on 3/28/22.
+//
+
+import LDKSwift
+import LDKHeaders
+
+/// serialization:
+/// 4 bytes: 0xD9B4BEF9
+/// 4 bytes: block size (remaining byte count)
+/// 80 bytes: block header
+/// VarInt (1-9 bytes): transaction count
+/// transactions
+
+class BTCBlock: Equatable {
+    
+    var version: UInt32 = 2
+    var previousBlockHash: [UInt8] = []
+    var merkleRoot: [UInt8]?
+    var timestamp: UInt32 = 0
+    var difficultyTarget: UInt32 = 0
+    var nonce: UInt32 = 0
+    
+    // each transaction is a uint8 array
+    var transactions: [BTCTransaction] = []
+    
+    func calculateMerkleRoot() -> [UInt8] {
+        // TODO: merkleize the transactions
+        if let merkleRoot = self.merkleRoot {
+            return merkleRoot
+        }
+        return [UInt8](repeating: 0, count: 32)
+    }
+    
+    func calculateHeader() -> [UInt8] {
+        var header = [UInt8]()
+        
+        do {
+            let versionBytes = withUnsafeBytes(of: self.version.littleEndian) { bytes in
+                Array(bytes)
+            }
+            assert(versionBytes.count == 4)
+            header.append(contentsOf: versionBytes)
+        }
+        
+        do {
+            assert(self.previousBlockHash.count == 32)
+            header.append(contentsOf: self.previousBlockHash)
+        }
+        
+        do {
+            let merkleRoot = self.calculateMerkleRoot()
+            assert(merkleRoot.count == 32)
+            header.append(contentsOf: merkleRoot)
+        }
+        
+        do {
+            let timestampBytes = withUnsafeBytes(of: self.timestamp.littleEndian) { bytes in
+                Array(bytes)
+            }
+            assert(timestampBytes.count == 4)
+            header.append(contentsOf: timestampBytes)
+        }
+        
+        do{
+            let difficultyTargetBytes = withUnsafeBytes(of: self.difficultyTarget.littleEndian) { bytes in
+                Array(bytes)
+            }
+            assert(difficultyTargetBytes.count == 4)
+            header.append(contentsOf: difficultyTargetBytes)
+        }
+        
+        do {
+            let nonceBytes = withUnsafeBytes(of: self.nonce.littleEndian) { bytes in
+                Array(bytes)
+            }
+            assert(nonceBytes.count == 4)
+            header.append(contentsOf: nonceBytes)
+        }
+        
+        assert(header.count == 80)
+        return header
+    }
+    
+    /// The double sha256 hash of the block header (note: not the entire block)
+    /// In a well-mined block, the zeroes should be trailing, as this hash is little-endian-equivalent
+    func calculateHash() -> [UInt8] {
+        let blockHeader = self.calculateHeader()
+        return BTCHashing.doubleSha256(blockHeader)
+    }
+    
+    func serialize() -> [UInt8] {
+        
+        var block = [UInt8]()
+        
+        // apparently, this only needs to be appended when it's actually part of a block
+        /*
+        do {
+            let magicNumber: UInt32 = 4190024921
+            let magicNumberBytes = withUnsafeBytes(of: magicNumber.littleEndian) { bytes in
+                Array(bytes)
+            }
+            assert(magicNumberBytes.count == 4)
+            assert(magicNumberBytes == [0xf9, 0xbe, 0xb4, 0xd9])
+            
+            block.append(contentsOf: magicNumberBytes)
+        }
+        */
+        
+        let blockHeader = self.calculateHeader()
+        let transactionCounter = BTCVarInt(UInt64(self.transactions.count)).serialize()
+        let transactionData = self.transactions.reduce(into: [UInt8]()) { partialResult, currentValue in
+            return partialResult.append(contentsOf: currentValue.serialize())
+        }
+        
+        /*
+        do {
+            let blockSize = blockHeader.count + transactionCounter.count + transactionData.count
+            let blockSizeBytes = withUnsafeBytes(of: UInt32(blockSize).littleEndian) { bytes in
+                Array(bytes)
+            }
+            assert(blockSizeBytes.count == 4)
+            block.append(contentsOf: blockSizeBytes)
+        }
+        */
+        
+        block.append(contentsOf: blockHeader)
+        block.append(contentsOf: transactionCounter)
+        block.append(contentsOf: transactionData)
+        
+        return block
+    }
+    
+    static func == (lhs: BTCBlock, rhs: BTCBlock) -> Bool {
+        return lhs.calculateHash() == rhs.calculateHash()
+    }
+    
+}

ci/LDKSwift/Tests/LDKSwiftTests/bitcoin/BTCHashing.swift

@@ -0,0 +1,29 @@
+//
+//  BTCHashing.swift
+//  DirectBindingsAppTests
+//
+//  Created by Arik Sosman on 3/29/22.
+//
+
+import LDKSwift
+import LDKHeaders
+import Crypto
+
+class BTCHashing {
+
+    public static let SHA_ZERO_HASH = [UInt8](repeating: 0, count: 32)
+    public static let RIPEMD_ZERO_HASH = [UInt8](repeating: 0, count: 20)
+
+    private static func sha256(_ input: [UInt8]) -> [UInt8] {
+        let hash = Crypto.SHA256.hash(data: input)
+        let bytes = Array(hash)
+        assert(bytes.count == 32)
+        return bytes
+    }
+
+    static func doubleSha256(_ input: [UInt8]) -> [UInt8] {
+        return sha256(sha256(input))
+    }
+
+}
+