|
|
|
|
@ -5,47 +5,43 @@ private extension UInt64 {
|
|
|
|
|
init(_ decimal: Decimal) {
|
|
|
|
|
self.init(truncating: decimal as NSDecimalNumber)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// UInt8 Array specific stuff we need
|
|
|
|
|
private extension Array where Element == UInt8 {
|
|
|
|
|
|
|
|
|
|
// Convert a UInt64 into an array of size 8
|
|
|
|
|
init(_ uint64: UInt64) {
|
|
|
|
|
let array = stride(from: 0, to: 64, by: 8).reversed().map {
|
|
|
|
|
UInt8(uint64 >> $0 & 0x000000FF)
|
|
|
|
|
// Convert a UInt8 array to a UInt64
|
|
|
|
|
init(_ bytes: [UInt8]) {
|
|
|
|
|
precondition(bytes.count <= MemoryLayout<UInt64>.size)
|
|
|
|
|
var value: UInt64 = 0
|
|
|
|
|
for byte in bytes {
|
|
|
|
|
value <<= 8
|
|
|
|
|
value |= UInt64(byte)
|
|
|
|
|
}
|
|
|
|
|
self.init(array)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static func > (lhs: [UInt8], rhs: [UInt8]) -> Bool {
|
|
|
|
|
guard lhs.count == rhs.count else { return false }
|
|
|
|
|
guard let (lhsElement, rhsElement) = zip(lhs, rhs).first(where: { $0 != $1 }) else { return false }
|
|
|
|
|
return lhsElement > rhsElement
|
|
|
|
|
self.init(value)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Increment the UInt8 array by a given amount
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private extension MutableCollection where Element == UInt8, Index == Int {
|
|
|
|
|
|
|
|
|
|
/// Increment every element by the given amount
|
|
|
|
|
///
|
|
|
|
|
/// - Parameter amount: The amount to increment by
|
|
|
|
|
/// - Returns: The incrememnted array
|
|
|
|
|
func increment(by amount: Int) -> [UInt8] {
|
|
|
|
|
var newNonce = self
|
|
|
|
|
/// - Returns: The incremented collection
|
|
|
|
|
func increment(by amount: Int) -> Self {
|
|
|
|
|
var result = self
|
|
|
|
|
var increment = amount
|
|
|
|
|
for i in (0..<newNonce.count).reversed() {
|
|
|
|
|
for i in (0..<result.count).reversed() {
|
|
|
|
|
guard increment > 0 else { break }
|
|
|
|
|
let sum = Int(newNonce[i]) + increment
|
|
|
|
|
newNonce[i] = UInt8(sum % 256)
|
|
|
|
|
let sum = Int(result[i]) + increment
|
|
|
|
|
result[i] = UInt8(sum % 256)
|
|
|
|
|
increment = sum / 256
|
|
|
|
|
}
|
|
|
|
|
return newNonce
|
|
|
|
|
return result
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The main logic which handles proof of work.
|
|
|
|
|
* The main proof of work logic.
|
|
|
|
|
*
|
|
|
|
|
* This was copied from the messenger desktop.
|
|
|
|
|
* Ref: libloki/proof-of-work.js
|
|
|
|
|
* This was copied from the desktop messenger.
|
|
|
|
|
* Ref: libloki/proof-of-work.js
|
|
|
|
|
*/
|
|
|
|
|
public enum ProofOfWork {
|
|
|
|
|
|
|
|
|
|
@ -59,33 +55,39 @@ public enum ProofOfWork {
|
|
|
|
|
}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
struct Configuration {
|
|
|
|
|
public struct Configuration {
|
|
|
|
|
var pubKey: String
|
|
|
|
|
var data: String
|
|
|
|
|
var timestamp: Date
|
|
|
|
|
var ttl: Int
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var payload: [UInt8] {
|
|
|
|
|
let timestampString = String(Int(timestamp.timeIntervalSince1970))
|
|
|
|
|
let ttlString = String(ttl)
|
|
|
|
|
let payloadString = timestampString + ttlString + pubKey + data
|
|
|
|
|
return payloadString.bytes
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public init(pubKey: String, data: String, timestamp: Date, ttl: Int) {
|
|
|
|
|
self.pubKey = pubKey
|
|
|
|
|
self.data = data
|
|
|
|
|
self.timestamp = timestamp
|
|
|
|
|
self.ttl = ttl
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// Calculate a proof of work for the given configuration
|
|
|
|
|
/// Calculate a proof of work with the given configuration
|
|
|
|
|
///
|
|
|
|
|
/// Ref: https://bitmessage.org/wiki/Proof_of_work
|
|
|
|
|
///
|
|
|
|
|
/// - Parameter config: The configuration data
|
|
|
|
|
/// - Parameter config: The configuration
|
|
|
|
|
/// - Returns: A nonce string or nil if it failed
|
|
|
|
|
static func calculate(with config: Configuration) -> String? {
|
|
|
|
|
public static func calculate(with config: Configuration) -> String? {
|
|
|
|
|
let payload = config.payload
|
|
|
|
|
let target = calcTarget(ttl: config.ttl, payloadLength: payload.count, nonceTrials: nonceTrialCount)
|
|
|
|
|
|
|
|
|
|
// Start with most the max value we can
|
|
|
|
|
var trialValue = [UInt8](repeating: UInt8.max, count: nonceLength)
|
|
|
|
|
// Start with the max value
|
|
|
|
|
var trialValue = UInt64.max
|
|
|
|
|
|
|
|
|
|
let initialHash = payload.sha512()
|
|
|
|
|
var nonce = [UInt8](repeating: 0, count: nonceLength)
|
|
|
|
|
@ -93,17 +95,18 @@ public enum ProofOfWork {
|
|
|
|
|
while trialValue > target {
|
|
|
|
|
nonce = nonce.increment(by: 1)
|
|
|
|
|
|
|
|
|
|
// This is different to the bitmessage pow
|
|
|
|
|
// This is different to the bitmessage POW
|
|
|
|
|
// resultHash = hash(nonce + hash(data)) ==> hash(nonce + initialHash)
|
|
|
|
|
let resultHash = (nonce + initialHash).sha512()
|
|
|
|
|
trialValue = Array(resultHash[0..<8])
|
|
|
|
|
let trialValueArray = Array(resultHash[0..<8])
|
|
|
|
|
trialValue = UInt64(trialValueArray)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return nonce.toBase64()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Calculate the UInt8 target we need to reach
|
|
|
|
|
private static func calcTarget(ttl: Int, payloadLength: Int, nonceTrials: Int) -> [UInt8] {
|
|
|
|
|
/// Calculate the target we need to reach
|
|
|
|
|
private static func calcTarget(ttl: Int, payloadLength: Int, nonceTrials: Int) -> UInt64 {
|
|
|
|
|
let two16 = UInt64(pow(2, 16) - 1)
|
|
|
|
|
let two64 = UInt64(pow(2, 64) - 1)
|
|
|
|
|
|
|
|
|
|
@ -118,8 +121,7 @@ public enum ProofOfWork {
|
|
|
|
|
let innerFrac = ttlMult / two16
|
|
|
|
|
let lenPlusInnerFrac = totalLength + innerFrac
|
|
|
|
|
let denominator = UInt64(nonceTrials) * lenPlusInnerFrac
|
|
|
|
|
let targetNum = two64 / denominator
|
|
|
|
|
|
|
|
|
|
return [UInt8](targetNum)
|
|
|
|
|
return two64 / denominator
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Niels Andriesse
5 years ago
committed by
GitHub