Feature/ethereum export

FearlessUtils/Classes/Crypto/KeypairFactory/EcdsaKeypairFactory.swift

@@ -8,8 +8,10 @@ public struct EcdsaKeypairFactory: DerivableSeedFactoryProtocol {
 
     public init() {}
 
-    public func createKeypairFromSeed(_ seed: Data,
-                                      chaincodeList: [Chaincode]) throws -> IRCryptoKeypairProtocol {
+    public func createKeypairFromSeed(
+        _ seed: Data,
+        chaincodeList: [Chaincode]
+    ) throws -> IRCryptoKeypairProtocol {
         let childSeed = try deriveChildSeedFromParent(seed, chaincodeList: chaincodeList)
         let childPrivateKey = try SECPrivateKey(rawData: childSeed)
         return try internalFactory.derive(fromPrivateKey: childPrivateKey)

FearlessUtils/Classes/Extrinsic/CryptoType+Extrinsic.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 extension CryptoType {
-    init?(onChainType: UInt8) {
+    public init?(onChainType: UInt8) {
         switch onChainType {
         case 0:
             self = .ed25519

FearlessUtils/Classes/Extrinsic/Extrinsic.swift

@@ -44,16 +44,19 @@ public struct ExtrinsicSignature: Codable {
         case address
         case signature
         case extra
+        case type
     }
 
     public let address: JSON
     public let signature: JSON
     public let extra: ExtrinsicSignedExtra
+    public let type: String
 
-    public init(address: JSON, signature: JSON, extra: ExtrinsicSignedExtra) {
+    public init(address: JSON, signature: JSON, extra: ExtrinsicSignedExtra, type: String) {
         self.address = address
         self.signature = signature
         self.extra = extra
+        self.type = type
     }
 }
 

FearlessUtils/Classes/Extrinsic/ExtrinsicBuilder.swift

@@ -189,24 +189,45 @@ extension ExtrinsicBuilder: ExtrinsicBuilderProtocol {
 
         let rawSignature = try signer(data)
 
-        let signature: MultiSignature
-
-        switch type {
-        case .sr25519:
-            signature = .sr25519(data: rawSignature)
-        case .ed25519:
-            signature = .ed25519(data: rawSignature)
-        case .ecdsa:
-            signature = .ecdsa(data: rawSignature)
+        var signatureJson = JSON.null
+        var signatureTypeString = KnownType.signature.rawValue
+
+        // Some networks like Moonbeam/Moonriver have signature as direct byte-array rather than MultiSignature enum
+        // Though they have MultiSignature enum in their metadata, check what signature type is used within extrinsic
+        // Otherwise provide default enum based MultiSignature behavior
+        if let extrinsicType = try? metadata.schemaResolver.typeMetadata(for: metadata.extrinsic.type) {
+            let signatureParam = extrinsicType.params.first { $0.name == "Signature" }
+            if let signatureType = try? metadata.schemaResolver.typeMetadata(for: signatureParam?.type) {
+                switch signatureType.def {
+                case .variant:
+                    break
+                default:
+                    signatureJson = try rawSignature.toScaleCompatibleJSON()
+                    signatureTypeString = try metadata.schemaResolver.typeName(for: signatureType)
+                }
+            }
         }
+
+        if signatureJson == .null {
+            let signature: MultiSignature
+            switch type {
+            case .sr25519:
+                signature = .sr25519(data: rawSignature)
+            case .ed25519:
+                signature = .ed25519(data: rawSignature)
+            case .ecdsa:
+                signature = .ecdsa(data: rawSignature)
+            }
 
-        let sigJson = try signature.toScaleCompatibleJSON()
+            signatureJson = try signature.toScaleCompatibleJSON()
+        }
 
         let extra = ExtrinsicSignedExtra(era: era, nonce: nonce ?? 0, tip: tip)
         self.signature = ExtrinsicSignature(
             address: address,
-            signature: sigJson,
-            extra: extra
+            signature: signatureJson,
+            extra: extra,
+            type: signatureTypeString
         )
 
         return self
@@ -217,11 +238,34 @@ extension ExtrinsicBuilder: ExtrinsicBuilderProtocol {
         metadata: RuntimeMetadata
     ) throws -> Data {
         let call = try prepareExtrinsicCall(for: metadata)
-
+
+        Log.enable(kind: "DynamicScale")
         let extrinsic = Extrinsic(signature: signature, call: call)
 
         try encoder.append(extrinsic, ofType: GenericType.extrinsic.name)
+
+        let encoded = try encoder.encode()
+        Log.write("DynamicScale", message: "Extrinsic encoded: \(encoded.toHex(includePrefix: true))")
+        Log.disable(kind: "DynamicScale")
+
+        return encoded
+    }
+}
 
-        return try encoder.encode()
+struct Log {
+    private static var enabled: [String] = []
+
+    static func enable(kind: String) {
+        enabled.append(kind)
+    }
+
+    static func disable(kind: String) {
+        enabled.removeAll { $0 == kind }
+    }
+
+    static func write(_ kind: String, message: String) {
+        if enabled.contains(kind) {
+            print("[\(kind)] \(message)")
+        }
     }
 }

FearlessUtils/Classes/Keystore/KeystoreBuilder.swift

@@ -11,6 +11,10 @@ public class KeystoreBuilder {
 }
 
 extension KeystoreBuilder: KeystoreBuilding {
+    enum Constants {
+        static let ethereum = "ethereum"
+    }
+
     public func with(name: String) -> Self {
         self.name = name
         return self
@@ -26,7 +30,7 @@ extension KeystoreBuilder: KeystoreBuilding {
         return self
     }
 
-    public func build(from data: KeystoreData, password: String?) throws -> KeystoreDefinition {
+    public func build(from data: KeystoreData, password: String?, isEthereum: Bool) throws -> KeystoreDefinition {
         let scryptParameters = try ScryptParameters()
 
         let scryptData: Data
@@ -64,17 +68,23 @@ extension KeystoreBuilder: KeystoreBuilding {
         let pcksData = KeystoreConstants.pkcs8Header + secretKeyData +
             KeystoreConstants.pkcs8Divider + data.publicKeyData
         let encrypted = try NaclSecretBox.secretBox(message: pcksData, nonce: nonce, key: encryptionKey)
+
         let encoded = scryptParameters.encode() + nonce + encrypted
 
+        let cryptoType = isEthereum ? Constants.ethereum : data.cryptoType.rawValue
         let encodingType = [KeystoreEncodingType.scrypt.rawValue, KeystoreEncodingType.xsalsa.rawValue]
-        let encodingContent = [KeystoreEncodingContent.pkcs8.rawValue, data.cryptoType.rawValue]
+        let encodingContent = [KeystoreEncodingContent.pkcs8.rawValue, cryptoType]
         let keystoreEncoding = KeystoreEncoding(content: encodingContent,
                                                 type: encodingType,
                                                 version: String(KeystoreConstants.version))
 
+        let isHardware: Bool? = isEthereum ? false : nil
+        let tags: [String]? = isEthereum ? [] : nil
         let meta = KeystoreMeta(name: name,
                                 createdAt: Int64(creationDate.timeIntervalSince1970),
-                                genesisHash: genesisHash)
+                                genesisHash: genesisHash,
+                                isHardware: isHardware,
+                                tags: tags)
 
         return KeystoreDefinition(address: data.address,
                                   encoded: encoded.base64EncodedString(),

FearlessUtils/Classes/Keystore/KeystoreCommon.swift

@@ -10,7 +10,7 @@ public protocol KeystoreBuilding {
     func with(creationDate: Date) -> Self
     func with(genesisHash: String) -> Self
 
-    func build(from data: KeystoreData, password: String?) throws -> KeystoreDefinition
+    func build(from data: KeystoreData, password: String?, isEthereum: Bool) throws -> KeystoreDefinition
 }
 
 public enum KeystoreExtractorError: Error {

FearlessUtils/Classes/Keystore/KeystoreDefinition.swift

@@ -34,9 +34,13 @@ public struct KeystoreMeta: Codable {
         case name
         case createdAt = "whenCreated"
         case genesisHash
+        case isHardware
+        case tags
     }
 
     public let name: String?
     public let createdAt: Int64?
     public let genesisHash: String?
+    public let isHardware: Bool?
+    public let tags: [String]?
 }

FearlessUtils/Classes/Network/WebSocketEngine+Delegate.swift

@@ -2,7 +2,7 @@ import Foundation
 import Starscream
 
 extension WebSocketEngine: WebSocketDelegate {
-    public func didReceive(event: WebSocketEvent, client _: WebSocket) {        
+    public func didReceive(event: WebSocketEvent, client _: WebSocket) {
         mutex.lock()
 
         switch event {

FearlessUtils/Classes/Network/WebSocketEngine+Protocol.swift

@@ -71,7 +71,7 @@ extension WebSocketEngine: JSONRPCEngine {
     }
 
     public func reconnect(url: URL) {
-        self.connection.disconnect()
+        self.connection.disconnect(closeCode: 0)
 
         self.url = url
         let request = URLRequest(url: url, timeoutInterval: 10)
@@ -81,15 +81,13 @@ extension WebSocketEngine: JSONRPCEngine {
             certPinner: FoundationSecurity(),
             compressionHandler: nil
         )
-
+        
         let connection = WebSocket(request: request, engine: engine)
-        connection.forceDisconnect()
         self.connection = connection
 
         connection.delegate = self
         connection.callbackQueue = Self.sharedProcessingQueue
-
-        self.changeState(.notConnected)
-        self.connectIfNeeded()
+
+        self.changeState(.connecting(attempt: 0))
     }
 }

FearlessUtils/Classes/Network/WebSocketEngine.swift

@@ -38,10 +38,7 @@ public final class WebSocketEngine {
             if let delegate = delegate {
                 let oldState = oldValue
                 let newState = state
-
-                completionQueue.async {
                     delegate.webSocketDidChangeState(engine: self, from: oldState, to: newState)
-                }
             }
         }
     }

FearlessUtils/Classes/Runtime/KnownType.swift

@@ -13,6 +13,7 @@ public enum KnownType: String, CaseIterable {
     case phase = "frame_system::Phase"
     case address = "sp_runtime::multiaddress::MultiAddress"
     case signature = "sp_runtime::MultiSignature"
+    case extrinsic = "sp_runtime::generic::unchecked_extrinsic::UncheckedExtrinsic"
     case addressId32 = "sp_core::crypto::AccountId32" // regular networks
     case addressId20 = "account::AccountId20" // ethereum-based networks like Moonbeam/Moonriver
 

FearlessUtils/Classes/Runtime/Metadata/ExtrinsicMetadata.swift

@@ -5,6 +5,7 @@ import BigInt
 
 public protocol RuntimeExtrinsicMetadata {
     var version: UInt8 { get }
+    var type: BigUInt? { get }
     func signedExtensions(using schemaResolver: Schema.Resolver) throws -> [String]
 }
 
@@ -13,6 +14,7 @@ public protocol RuntimeExtrinsicMetadata {
 extension RuntimeMetadataV1 {
     public struct ExtrinsicMetadata: RuntimeExtrinsicMetadata {
         public let version: UInt8
+        public let type: BigUInt? = nil
         public let signedExtensions: [String]
 
         public init(version: UInt8, signedExtensions: [String]) {
@@ -42,12 +44,13 @@ extension RuntimeMetadataV1.ExtrinsicMetadata: ScaleCodable {
 
 extension RuntimeMetadataV14 {
     public struct ExtrinsicMetadata: RuntimeExtrinsicMetadata {
-        public let type: BigUInt
+        private let _type: BigUInt
+        public var type: BigUInt? { _type }
         public let version: UInt8
         public let signedExtensions: [SignedExtension]
 
         public init(type: BigUInt, version: UInt8, signedExtensions: [SignedExtension]) {
-            self.type = type
+            self._type = type
             self.version = version
             self.signedExtensions = signedExtensions
         }
@@ -62,13 +65,13 @@ extension RuntimeMetadataV14 {
 
 extension RuntimeMetadataV14.ExtrinsicMetadata: ScaleCodable {
     public func encode(scaleEncoder: ScaleEncoding) throws {
-        try type.encode(scaleEncoder: scaleEncoder)
+        try _type.encode(scaleEncoder: scaleEncoder)
         try version.encode(scaleEncoder: scaleEncoder)
         try signedExtensions.encode(scaleEncoder: scaleEncoder)
     }
 
     public init(scaleDecoder: ScaleDecoding) throws {
-        type = try BigUInt(scaleDecoder: scaleDecoder)
+        _type = try BigUInt(scaleDecoder: scaleDecoder)
         version = try UInt8(scaleDecoder: scaleDecoder)
         signedExtensions = try [SignedExtension](scaleDecoder: scaleDecoder)
     }

FearlessUtils/Classes/Runtime/Nodes/Items/ExtrinsicSignatureNode.swift

@@ -45,7 +45,9 @@ public class ExtrinsicSignatureNode: Node {
         guard
             var address = params[ExtrinsicSignature.CodingKeys.address.rawValue],
             let signature = params[ExtrinsicSignature.CodingKeys.signature.rawValue],
-            let extra = params[ExtrinsicSignature.CodingKeys.extra.rawValue] else {
+            let extra = params[ExtrinsicSignature.CodingKeys.extra.rawValue],
+            let signatureType = params[ExtrinsicSignature.CodingKeys.type.rawValue]?.stringValue
+        else {
             throw ExtrinsicSignatureNodeError.invalidParams
         }
 
@@ -63,7 +65,7 @@ public class ExtrinsicSignatureNode: Node {
         }
 
         try encoder.append(json: address, type: addressType.name)
-        try encoder.append(json: signature, type: KnownType.signature.name)
+        try encoder.append(json: signature, type: signatureType)
         try encoder.append(json: extra, type: GenericType.extrinsicExtra.name)
     }
 

FearlessUtils/Classes/Runtime/TypeRegistry+Public.swift

@@ -49,6 +49,7 @@ public extension TypeRegistry {
 
         return try TypeRegistry(
             json: types,
+            overrides: json["overrides"]?.arrayValue,
             nodeFactory: OneOfTypeNodeFactory(children: factories),
             typeResolver: OneOfTypeResolver(children: resolvers),
             additionalNodes: additionalNodes