network transaction wrapper enum, history pagination, parse multi-signature accounts and blocks, merge network ID & alias; fix ASN1 generalized time DER decoding

Author: davidscheutz

Package.resolved

@@ -5,7 +5,7 @@ import PackageDescription
 
 let package = Package(
     name: "KeetaClient",
-    platforms: [.iOS("14.0"), .macOS(.v11)],
+    platforms: [.iOS("15.0"), .macOS(.v11)],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(
@@ -18,7 +18,7 @@ let package = Package(
         .package(url: "https://github.com/attaswift/BigInt.git", .upToNextMajor(from: "5.3.0")),
         .package(url: "https://github.com/apple/swift-asn1.git", from: "1.3.0"),
         .package(url: "https://github.com/krzyzanowskim/CryptoSwift.git", .upToNextMajor(from: "1.8.5")),
-        .package(url: "https://github.com/outfoxx/PotentCodables.git", from: "3.5.2"),
+        .package(url: "https://github.com/KeetaNetwork/PotentCodables.git", branch: "der-generalized-time-omit-zeros"),
         .package(url: "https://github.com/bitmark-inc/bip39-swift.git", from: "1.0.1"),
         .package(url: "https://github.com/norio-nomura/Base32.git", from: "0.5.4")
     ],

Package.swift

@@ -126,13 +126,13 @@ Supported Operations
 let config: NetworkConfig = try .create(for: .test)
 
 let sendBlock = try BlockBuilder()
-        .start(from: nil, network: config.networkID)
+        .start(from: nil, network: config.network)
         .add(account: senderAccount) // the block will be added to it's chain
         .add(operation: SendOperation(amount: 10, to: recipientAccount, token: baseToken))
         .seal()
 
 let consecutiveBlock = try BlockBuilder()
-        .start(from: sendBlock.hash, network: config.networkID)
+        .start(from: sendBlock.hash, network: config.network)
         .add(account: tokenAccount)
         .add(signer: ownerAccount) // sign on behalf of token account
         .add(operation: SetInfoOperation(name: "Demo Account".uppercased()))

README.md

@@ -96,7 +96,7 @@ public struct Account: Codable, Hashable {
 
     private func prepare(data: Data, options: SigningOptions) throws -> [UInt8] {
         if options.raw {
-            let data = data.bytes
+            let data = data.toBytes()
             if data.count != Hash.digestLength {
                 throw AccountError.invalidDataLength
             }
@@ -114,13 +114,16 @@ extension Account {
         case ED25519
         case NETWORK
         case TOKEN
+        case STORAGE
+        case MULTISIG = 7
 
         var utils: (KeyCreateable & Signable & Verifiable).Type {
             get throws {
                 switch self {
                 case .ECDSA_SECP256K1: EcDSA.self
                 case .ED25519: Ed25519.self
-                case .NETWORK, .TOKEN: IdentifierKeyPair.self
+                case .NETWORK, .TOKEN, .STORAGE: IdentifierKeyPair.self
+                case .MULTISIG: MultiSignatureKeyPair.self
                 }
             }
         }

Sources/KeetaClient/Account/Account.swift

@@ -14,12 +14,25 @@ public struct AccountBuilder {
         fromSeed seed: String,
         index: Int,
         algorithm: Account.KeyAlgorithm = .ECDSA_SECP256K1
+    ) throws -> Account {
+        try create(fromSeed: try seed.toBytes(), index: index, algorithm: algorithm)
+    }
+    
+    public static func create(
+        fromSeed seed: [UInt8],
+        index: Int,
+        algorithm: Account.KeyAlgorithm = .ECDSA_SECP256K1
     ) throws -> Account {
         let seedBase = try combine(seed: seed, and: index)
         let keyPair = try algorithm.utils.create(from: seedBase)
         return try .init(keyPair: keyPair, keyAlgorithm: algorithm)
     }
 
+    public static func create(for config: NetworkConfig) throws -> Account {
+        let seed = config.network.id.toData(length: 32).toBytes()
+        return try create(fromSeed: seed, index: 0, algorithm: .NETWORK)
+    }
+    
     public static func create(fromPublicKey publicKey: String) throws -> Account {
         var key = publicKey
 
@@ -81,6 +94,10 @@ public struct AccountBuilder {
     // MARK: - Internal
 
     static func combine(seed: String, and index: Int) throws -> String {
+        try combine(seed: try seed.toBytes(), and: index)
+    }
+    
+    static func combine(seed: [UInt8], and index: Int) throws -> String {
         guard index >= 0 else {
             throw AccountBuilderError.seedIndexNegative
         }
@@ -91,14 +108,14 @@ public struct AccountBuilder {
             throw AccountBuilderError.seedIndexTooLarge
         }
 
-        var seedBytes = try seed.toBytes()
+        var mutableSeed = seed
 
-        seedBytes.append(UInt8(indexValue >> BigInt(24) & BigInt(0xff)))
-        seedBytes.append(UInt8(indexValue >> BigInt(16) & BigInt(0xff)))
-        seedBytes.append(UInt8(indexValue >> BigInt(8)  & BigInt(0xff)))
-        seedBytes.append(UInt8(indexValue               & BigInt(0xff)))
+        mutableSeed.append(UInt8(indexValue >> BigInt(24) & BigInt(0xff)))
+        mutableSeed.append(UInt8(indexValue >> BigInt(16) & BigInt(0xff)))
+        mutableSeed.append(UInt8(indexValue >> BigInt(8)  & BigInt(0xff)))
+        mutableSeed.append(UInt8(indexValue               & BigInt(0xff)))
 
-        return .init(bytes: seedBytes).uppercased()
+        return .init(bytes: mutableSeed).uppercased()
     }
 
 }

Sources/KeetaClient/Account/AccountBuilder.swift

@@ -0,0 +1,35 @@
+//
+//  MultiSignatureKeyPair.swift
+//  KeetaClient
+//
+//  Created by David Scheutz on 11/6/25.
+//
+
+public enum MultiSignatureKeyPairError: Error {
+    case signingNotSupported
+    case verifyingNotSupported
+    case noPrivateKey
+}
+
+public struct MultiSignatureKeyPair: KeyCreateable, Signable, Verifiable {
+    static func create(from seed: String) throws -> KeyPair {
+        let privateKey: String = Hash.create(from: try seed.toBytes())
+        return try keypair(from: privateKey)
+    }
+    
+    static func keypair(from privateKey: String) throws -> KeyPair {
+        .init(publicKey: privateKey, privateKey: privateKey)
+    }
+    
+    static func sign(data: [UInt8], key: [UInt8]) throws -> [UInt8] {
+        throw MultiSignatureKeyPairError.signingNotSupported
+    }
+    
+    static func verify(data: [UInt8], signature: Signature, key: [UInt8]) throws -> Bool {
+        throw MultiSignatureKeyPairError.verifyingNotSupported
+    }
+    
+    static func signatureFromDER(_ signature: Signature) throws -> Signature {
+        throw MultiSignatureKeyPairError.noPrivateKey
+    }
+}

Sources/KeetaClient/Account/MultiSignatureKeyPair.swift

@@ -9,22 +9,13 @@ public typealias SubnetID = BigInt
 public enum BlockSignature: Hashable {
     case single(Signature)
     case multi([Signature])
-    
-    func toHexString() -> String {
-        switch self {
-        case .single(let signature): signature.toHexString()
-        case .multi(let signatures): "Multi-signatures not implemented"
-        }
-    }
 }
 
 public struct Block {
-    public typealias Signature = BlockSignature
-    
     public let rawData: RawBlockData
     public let opening: Bool
     public let hash: String
-    public let signature: Signature
+    public let signature: BlockSignature
 
     public enum Version: Int, CaseIterable {
         case v1
@@ -56,20 +47,15 @@ public struct Block {
         let hash = try rawBlock.hash()
         let hashBytes = try hash.toBytes()
 
-        let verifiedSignature: Signature
+        let verifiedSignature: BlockSignature
         if let signature = signature {
-            switch signature {
-            case .single(let signature):
-                let verified = try rawBlock.signer.verify(data: Data(hashBytes), signature: signature)
-                guard verified else {
-                    throw BlockError.invalidSignature
-                }
-                verifiedSignature = .single(signature)
-            case .multi:
-                throw NSError(domain: "Multi-signatures not implemented", code: 0)
+            let verified = try rawBlock.signer.account.verify(data: Data(hashBytes), signature: signature)
+            guard verified else {
+                throw BlockError.invalidSignature
             }
+            verifiedSignature = .single(signature)
         } else {
-            verifiedSignature = .single(try rawBlock.signer.sign(data: Data(hashBytes)))
+            verifiedSignature = .single(try rawBlock.signer.account.sign(data: Data(hashBytes)))
         }
 
         self.rawData = rawBlock
@@ -122,7 +108,7 @@ public struct Block {
         }
 
         let rawBlock: RawBlockData
-        let signature: Signature
+        let signature: BlockSignature
         let opening: Bool
 
         switch version {
@@ -134,6 +120,15 @@ public struct Block {
         self.opening = opening
         self.hash = try rawBlock.hash()
         self.signature = signature
+        
+        // Verify block signature
+        switch signature {
+        case .single(let signature):
+            let verified = try rawBlock.signer.account.verify(data: Data(try hash.toBytes()), signature: signature)
+            if !verified { throw BlockError.invalidSignature }
+        case .multi:
+            break // currently not supported
+        }
     }
 
     public func toAsn1() throws -> [ASN1] {
@@ -143,7 +138,7 @@ public struct Block {
         case .single(let signature):
             rawASN1 + [.octetString(.init(signature))]
         case .multi(let signatures):
-            rawASN1 + signatures.map { .octetString(.init($0)) }
+            rawASN1 + [.sequence(signatures.map { .octetString(Data($0)) })]
         }
     }
 
@@ -163,7 +158,7 @@ public struct Block {
 
     // MARK: Helper
 
-    private static func blockDataV1(for sequence: [ASN1]) throws -> (RawBlockData, Signature, Bool) {
+    private static func blockDataV1(for sequence: [ASN1]) throws -> (RawBlockData, BlockSignature, Bool) {
         guard let network = sequence[1].integerValue else {
             throw BlockError.invalidNetwork
         }
@@ -216,7 +211,7 @@ public struct Block {
             previous: previousHash,
             network: network,
             subnet: subnet,
-            signer: signer,
+            signer: .single(signer),
             account: account,
             operations: operations,
             created: anyTime.zonedDate.utcDate
@@ -225,7 +220,7 @@ public struct Block {
         return (rawBlock, .single(signature.bytes), opening)
     }
 
-    private static func blockDataV2(for sequence: [ASN1]) throws -> (RawBlockData, Signature, Bool) {
+    private static func blockDataV2(for sequence: [ASN1]) throws -> (RawBlockData, BlockSignature, Bool) {
         guard let network = sequence[0].integerValue else {
             throw BlockError.invalidNetwork
         }
@@ -249,14 +244,13 @@ public struct Block {
         let account = try Account(data: accountData)
 
         let signerContainer = sequence[6 - offset]
-        let signer: Account
+        let signer: RawBlockData.Signer
         if signerContainer.isNull {
-            signer = account
+            signer = .single(account)
         } else if let signerData = signerContainer.octetStringValue {
-            signer = try Account(data: signerData)
+            signer = .single(try Account(data: signerData))
         } else {
-            // TODO: implement 'this.signer = parseBlockSignerFieldContainer(signersContainer).parsed;'
-            throw NSError(domain: "Multi-signatures not implemented", code: 0)
+            signer = try parseMultiSig(signerContainer)
         }
 
         guard let previousHashData = sequence[7 - offset].octetStringValue else {
@@ -270,11 +264,16 @@ public struct Block {
         let operations = try operationsSequence.map { try BlockOperationBuilder.create(from: $0) }
 
         let signatureContainer = sequence[9 - offset]
-        let signature: Signature
+        let signature: BlockSignature
         if let signatureValue = signatureContainer.octetStringValue {
             signature = .single(signatureValue.bytes)
+        } else if let signatureValues = signatureContainer.sequenceValue {
+            let signatures = signatureValues.compactMap { $0.octetStringValue?.bytes }
+            guard !signatures.isEmpty && signatures.count == signatureValues.count else {
+                throw BlockError.missingMultiSigSignatures
+            }
+            signature = .multi(signatures)
         } else {
-            // TODO: implement 'assertBlockSignatureField(signatureContainer);'
             throw BlockError.invalidSignature
         }
 
@@ -296,12 +295,43 @@ public struct Block {
         return (rawBlock, signature, opening)
     }
 
-    private static func parseIdempotent(from asn1: ASN1) throws -> String? {
-        guard let idempotentData = asn1.octetStringValue else { return nil }
+    private static func parseMultiSig(_ container: ASN1, depth: Int = 0) throws -> RawBlockData.Signer {
+        guard depth <= 3 else {
+            throw BlockError.invalidMultiSigSignersDepth
+        }
+        
+        guard let sequence = container.sequenceValue, sequence.count == 2 else {
+            throw BlockError.invalidMultiSigSequence
+        }
+        
+        guard let multiSigData = sequence[0].octetStringValue else {
+            throw BlockError.invalidMultiSigAccount
+        }
+        
+        let account = try Account(data: multiSigData)
 
-        guard let idempotentString = String(data: idempotentData, encoding: .utf8) else {
-            throw BlockError.invalidIdempotentData
+        guard let signersSequence = sequence[1].sequenceValue else {
+            throw BlockError.missingMultiSigSigners
         }
+        
+        var signers = [RawBlockData.Signer]()
+        
+        for item in signersSequence {
+            if let accountData = item.octetStringValue {
+                signers.append(.single(try Account(data: accountData)))
+            } else if item.sequenceValue != nil {
+                signers.append(try parseMultiSig(item, depth: depth + 1))
+            } else {
+                throw BlockError.invalidMultiSigSigners
+            }
+        }
+        
+        return .multi(account, signers)
+    }
+    
+    private static func parseIdempotent(from asn1: ASN1) throws -> String? {
+        guard let idempotentData = asn1.octetStringValue else { return nil }
+        let idempotentString = String(data: idempotentData, encoding: .utf8) ?? idempotentData.base64EncodedString()
         return idempotentString
     }
 }